2 * Miscellaneous Bacula memory and thread safe routines
3 * Generally, these are interfaces to system or standard
6 * Bacula utility functions are in util.c
11 Copyright (C) 2000-2006 Kern Sibbald
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License
15 version 2 as amended with additional clauses defined in the
16 file LICENSE in the main source directory.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 the file LICENSE for additional details.
34 static pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
35 static pthread_cond_t timer = PTHREAD_COND_INITIALIZER;
38 * This routine will sleep (sec, microsec). Note, however, that if a
39 * signal occurs, it will return early. It is up to the caller
40 * to recall this routine if he/she REALLY wants to sleep the
43 int bmicrosleep(time_t sec, long usec)
45 struct timespec timeout;
51 timeout.tv_nsec = usec * 1000;
54 stat = nanosleep(&timeout, NULL);
55 if (!(stat < 0 && errno == ENOSYS)) {
58 /* If we reach here it is because nanosleep is not supported by the OS */
61 /* Do it the old way */
62 gettimeofday(&tv, &tz);
63 timeout.tv_nsec += tv.tv_usec * 1000;
64 timeout.tv_sec += tv.tv_sec;
65 while (timeout.tv_nsec >= 1000000000) {
66 timeout.tv_nsec -= 1000000000;
70 Dmsg2(200, "pthread_cond_timedwait sec=%d usec=%d\n", sec, usec);
71 /* Note, this unlocks mutex during the sleep */
73 stat = pthread_cond_timedwait(&timer, &timer_mutex, &timeout);
76 Dmsg2(200, "pthread_cond_timedwait stat=%d ERR=%s\n", stat,
84 * Guarantee that the string is properly terminated */
85 char *bstrncpy(char *dest, const char *src, int maxlen)
87 strncpy(dest, src, maxlen-1);
93 * Guarantee that the string is properly terminated */
94 char *bstrncpy(char *dest, POOL_MEM &src, int maxlen)
96 strncpy(dest, src.c_str(), maxlen-1);
102 char *bstrncat(char *dest, const char *src, int maxlen)
104 strncat(dest, src, maxlen-1);
109 char *bstrncat(char *dest, POOL_MEM &src, int maxlen)
111 strncat(dest, src.c_str(), maxlen-1);
117 * Allows one or both pointers to be NULL
119 bool bstrcmp(const char *s1, const char *s2)
121 if (s1 == s2) return true;
122 if (s1 == NULL || s2 == NULL) return false;
123 return strcmp(s1, s2) == 0;
127 * Get character length of UTF-8 string
130 * U-00000000 - U-0000007F: 0xxxxxxx
131 * U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
132 * U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
133 * U-00010000 - U-001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
134 * U-00200000 - U-03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
135 * U-04000000 - U-7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
137 int cstrlen(const char *str)
139 uint8_t *p = (uint8_t *)str;
142 if ((*p & 0xC0) != 0xC0) {
147 if ((*p & 0xD0) == 0xC0) {
152 if ((*p & 0xF0) == 0xD0) {
157 if ((*p & 0xF8) == 0xF0) {
162 if ((*p & 0xFC) == 0xF8) {
167 if ((*p & 0xFE) == 0xFC) {
172 p++; /* Shouln't get here but must advance */
180 void *bmalloc(size_t size)
186 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
192 void *b_malloc(const char *file, int line, size_t size)
197 buf = sm_malloc(file, line, size);
202 e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
208 void *brealloc (void *buf, size_t size)
210 buf = realloc(buf, size);
212 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
218 void *bcalloc (size_t size1, size_t size2)
222 buf = calloc(size1, size2);
224 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
229 /* Code now in src/lib/bsnprintf.c */
230 #ifndef USE_BSNPRINTF
236 int bsnprintf(char *str, int32_t size, const char *fmt, ...)
241 va_start(arg_ptr, fmt);
242 len = bvsnprintf(str, size, fmt, arg_ptr);
248 * Implement vsnprintf()
250 int bvsnprintf(char *str, int32_t size, const char *format, va_list ap)
252 #ifdef HAVE_VSNPRINTF
254 len = vsnprintf(str, size, format, ap);
262 buflen = size > BIG_BUF ? size : BIG_BUF;
263 buf = get_memory(buflen);
264 len = vsprintf(buf, format, ap);
266 Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
268 memcpy(str, buf, len);
269 str[len] = 0; /* len excludes the null */
274 #endif /* USE_BSNPRINTF */
276 #ifndef HAVE_LOCALTIME_R
278 struct tm *localtime_r(const time_t *timep, struct tm *tm)
280 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
284 ltm = localtime(timep);
286 memcpy(tm, ltm, sizeof(struct tm));
289 return ltm ? tm : NULL;
291 #endif /* HAVE_LOCALTIME_R */
293 #ifndef HAVE_READDIR_R
297 int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
299 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
305 ndir = readdir(dirp);
308 memcpy(entry, ndir, sizeof(struct dirent));
309 strcpy(entry->d_name, ndir->d_name);
319 #endif /* HAVE_READDIR_R */
322 int bstrerror(int errnum, char *buf, size_t bufsiz)
324 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
330 msg = strerror(errnum);
332 msg = _("Bad errno");
335 bstrncpy(buf, msg, bufsiz);
341 * These are mutex routines that do error checking
342 * for deadlock and such. Normally not turned on.
345 void _p(char *file, int line, pthread_mutex_t *m)
348 if ((errstat = pthread_mutex_trylock(m))) {
349 e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock.\n"));
350 /* We didn't get the lock, so do it definitely now */
351 if ((errstat=pthread_mutex_lock(m))) {
353 e_msg(file, line, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
354 be.strerror(errstat));
356 e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock resolved.\n"));
362 void _v(char *file, int line, pthread_mutex_t *m)
366 if ((errstat=pthread_mutex_trylock(m)) == 0) {
368 e_msg(file, line, M_ERROR, 0, _("Mutex unlock not locked. ERR=%s\n"),
369 be.strerror(errstat));
371 if ((errstat=pthread_mutex_unlock(m))) {
373 e_msg(file, line, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
374 be.strerror(errstat));
380 void _p(pthread_mutex_t *m)
383 if ((errstat=pthread_mutex_lock(m))) {
385 e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
386 be.strerror(errstat));
390 void _v(pthread_mutex_t *m)
393 if ((errstat=pthread_mutex_unlock(m))) {
395 e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
396 be.strerror(errstat));
400 #endif /* DEBUG_MUTEX */
403 /* These routines are not normally turned on */
405 void b_memset(const char *file, int line, void *mem, int val, size_t num)
407 /* Testing for 2000 byte zero at beginning of Volume block */
408 if (num > 1900 && num < 3000) {
409 Pmsg3(000, _("Memset for %d bytes at %s:%d\n"), (int)num, file, line);
411 memset(mem, val, num);
415 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
416 static int del_pid_file_ok = FALSE;
420 * Create a standard "Unix" pid file.
422 void create_pid_file(char *dir, const char *progname, int port)
424 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
428 POOLMEM *fname = get_pool_memory(PM_FNAME);
431 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
432 if (stat(fname, &statp) == 0) {
433 /* File exists, see what we have */
435 if ((pidfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0 ||
436 read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
437 sscanf(pidbuf, "%d", &oldpid) != 1) {
438 Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname, strerror(errno));
440 /* See if other Bacula is still alive */
441 if (kill(oldpid, 0) != -1 || errno != ESRCH) {
442 Emsg3(M_ERROR_TERM, 0, _("%s is already running. pid=%d\nCheck file %s\n"),
443 progname, oldpid, fname);
445 /* He is not alive, so take over file ownership */
446 unlink(fname); /* remove stale pid file */
448 /* Create new pid file */
449 if ((pidfd = open(fname, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, 0640)) >= 0) {
450 len = sprintf(pidbuf, "%d\n", (int)getpid());
451 write(pidfd, pidbuf, len);
453 del_pid_file_ok = TRUE; /* we created it so we can delete it */
455 Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname, strerror(errno));
457 free_pool_memory(fname);
463 * Delete the pid file if we created it
465 int delete_pid_file(char *dir, const char *progname, int port)
467 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
468 POOLMEM *fname = get_pool_memory(PM_FNAME);
470 if (!del_pid_file_ok) {
471 free_pool_memory(fname);
474 del_pid_file_ok = FALSE;
475 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
477 free_pool_memory(fname);
485 uint64_t last_jobs_addr;
486 uint64_t reserved[20];
489 static struct s_state_hdr state_hdr = {
505 #define lseek _lseeki64
507 #define O_BINARY _O_BINARY
511 * Open and read the state file for the daemon
513 void read_state_file(char *dir, const char *progname, int port)
518 POOLMEM *fname = get_pool_memory(PM_FNAME);
519 struct s_state_hdr hdr;
520 int hdr_size = sizeof(hdr);
522 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
523 /* If file exists, see what we have */
524 // Dmsg1(10, "O_BINARY=%d\n", O_BINARY);
525 if ((sfd = open(fname, O_RDONLY|O_BINARY)) < 0) {
526 Dmsg3(010, "Could not open state file. sfd=%d size=%d: ERR=%s\n",
527 sfd, sizeof(hdr), strerror(errno));
530 if ((stat=read(sfd, &hdr, hdr_size)) != hdr_size) {
531 Dmsg4(010, "Could not read state file. sfd=%d stat=%d size=%d: ERR=%s\n",
532 sfd, (int)stat, hdr_size, strerror(errno));
535 if (hdr.version != state_hdr.version) {
536 Dmsg2(010, "Bad hdr version. Wanted %d got %d\n",
537 state_hdr.version, hdr.version);
541 if (strcmp(hdr.id, state_hdr.id) != 0) {
542 Dmsg0(000, "State file header id invalid.\n");
545 // Dmsg1(010, "Read header of %d bytes.\n", sizeof(hdr));
546 if (!read_last_jobs_list(sfd, hdr.last_jobs_addr)) {
557 free_pool_memory(fname);
561 * Write the state file
563 void write_state_file(char *dir, const char *progname, int port)
567 POOLMEM *fname = get_pool_memory(PM_FNAME);
569 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
570 /* Create new state file */
572 if ((sfd = open(fname, O_CREAT|O_WRONLY|O_BINARY, 0640)) < 0) {
574 Dmsg2(000, "Could not create state file. %s ERR=%s\n", fname, be.strerror());
575 Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, be.strerror());
578 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
580 Dmsg1(000, "Write hdr error: ERR=%s\n", be.strerror());
583 // Dmsg1(010, "Wrote header of %d bytes\n", sizeof(state_hdr));
584 state_hdr.last_jobs_addr = sizeof(state_hdr);
585 state_hdr.reserved[0] = write_last_jobs_list(sfd, state_hdr.last_jobs_addr);
586 // Dmsg1(010, "write last job end = %d\n", (int)state_hdr.reserved[0]);
587 if (lseek(sfd, 0, SEEK_SET) < 0) {
589 Dmsg1(000, "lseek error: ERR=%s\n", be.strerror());
592 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
594 Pmsg1(000, _("Write final hdr error: ERR=%s\n"), be.strerror());
598 // Dmsg1(010, "rewrote header = %d\n", sizeof(state_hdr));
606 free_pool_memory(fname);
611 * Drop to privilege new userid and new gid if non-NULL
613 void drop(char *uid, char *gid)
620 if ((group = getgrnam(gid)) == NULL) {
621 Emsg1(M_ERROR_TERM, 0, _("Could not find specified group: %s\n"), gid);
623 if (setgid(group->gr_gid)) {
624 Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
626 gr_list[0] = group->gr_gid;
627 if (setgroups(1, gr_list)) {
628 Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
635 struct passwd *passw;
636 if ((passw = getpwnam(uid)) == NULL) {
637 Emsg1(M_ERROR_TERM, 0, _("Could not find specified userid: %s\n"), uid);
639 if (setuid(passw->pw_uid)) {
640 Emsg1(M_ERROR_TERM, 0, _("Could not set specified userid: %s\n"), uid);
648 /* BSDI does not have this. This is a *poor* simulation */
651 strtoll(const char *ptr, char **endptr, int base)
653 return (long long int)strtod(ptr, endptr);
658 * Bacula's implementation of fgets(). The difference is that it handles
659 * being interrupted by a signal (e.g. a SIGCHLD).
662 char *bfgets(char *s, int size, FILE *fd)
667 for (int i=0; i < size-1; i++) {
671 } while (ch == -1 && (errno == EINTR || errno == EAGAIN));
681 if (ch == '\r') { /* Support for Mac/Windows file format */
683 if (ch == '\n') { /* Windows (\r\n) */
687 else { /* Mac (\r only) */
688 (void)ungetc(ch, fd); /* Push next character back to fd */
700 * Make a "unique" filename. It is important that if
701 * called again with the same "what" that the result
702 * will be identical. This allows us to use the file
703 * without saving its name, and re-generate the name
704 * so that it can be deleted.
706 void make_unique_filename(POOLMEM **name, int Id, char *what)
708 Mmsg(name, "%s/%s.%s.%d.tmp", working_directory, my_name, what, Id);