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)
187 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.strerror());
193 void *b_malloc(const char *file, int line, size_t size)
198 buf = sm_malloc(file, line, size);
204 e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.strerror());
210 void *brealloc (void *buf, size_t size)
212 buf = realloc(buf, size);
215 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.strerror());
221 void *bcalloc (size_t size1, size_t size2)
225 buf = calloc(size1, size2);
228 Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), be.strerror());
233 /* Code now in src/lib/bsnprintf.c */
234 #ifndef USE_BSNPRINTF
240 int bsnprintf(char *str, int32_t size, const char *fmt, ...)
245 va_start(arg_ptr, fmt);
246 len = bvsnprintf(str, size, fmt, arg_ptr);
252 * Implement vsnprintf()
254 int bvsnprintf(char *str, int32_t size, const char *format, va_list ap)
256 #ifdef HAVE_VSNPRINTF
258 len = vsnprintf(str, size, format, ap);
266 buflen = size > BIG_BUF ? size : BIG_BUF;
267 buf = get_memory(buflen);
268 len = vsprintf(buf, format, ap);
270 Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
272 memcpy(str, buf, len);
273 str[len] = 0; /* len excludes the null */
278 #endif /* USE_BSNPRINTF */
280 #ifndef HAVE_LOCALTIME_R
282 struct tm *localtime_r(const time_t *timep, struct tm *tm)
284 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
288 ltm = localtime(timep);
290 memcpy(tm, ltm, sizeof(struct tm));
293 return ltm ? tm : NULL;
295 #endif /* HAVE_LOCALTIME_R */
297 #ifndef HAVE_READDIR_R
301 int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
303 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
309 ndir = readdir(dirp);
312 memcpy(entry, ndir, sizeof(struct dirent));
313 strcpy(entry->d_name, ndir->d_name);
323 #endif /* HAVE_READDIR_R */
326 int bstrerror(int errnum, char *buf, size_t bufsiz)
328 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
334 msg = strerror(errnum);
336 msg = _("Bad errno");
339 bstrncpy(buf, msg, bufsiz);
345 * These are mutex routines that do error checking
346 * for deadlock and such. Normally not turned on.
349 void _p(char *file, int line, pthread_mutex_t *m)
352 if ((errstat = pthread_mutex_trylock(m))) {
353 e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock.\n"));
354 /* We didn't get the lock, so do it definitely now */
355 if ((errstat=pthread_mutex_lock(m))) {
357 e_msg(file, line, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
358 be.strerror(errstat));
360 e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock resolved.\n"));
366 void _v(char *file, int line, pthread_mutex_t *m)
370 if ((errstat=pthread_mutex_trylock(m)) == 0) {
372 e_msg(file, line, M_ERROR, 0, _("Mutex unlock not locked. ERR=%s\n"),
373 be.strerror(errstat));
375 if ((errstat=pthread_mutex_unlock(m))) {
377 e_msg(file, line, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
378 be.strerror(errstat));
384 void _p(pthread_mutex_t *m)
387 if ((errstat=pthread_mutex_lock(m))) {
389 e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
390 be.strerror(errstat));
394 void _v(pthread_mutex_t *m)
397 if ((errstat=pthread_mutex_unlock(m))) {
399 e_msg(__FILE__, __LINE__, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
400 be.strerror(errstat));
404 #endif /* DEBUG_MUTEX */
407 /* These routines are not normally turned on */
409 void b_memset(const char *file, int line, void *mem, int val, size_t num)
411 /* Testing for 2000 byte zero at beginning of Volume block */
412 if (num > 1900 && num < 3000) {
413 Pmsg3(000, _("Memset for %d bytes at %s:%d\n"), (int)num, file, line);
415 memset(mem, val, num);
419 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
420 static int del_pid_file_ok = FALSE;
424 * Create a standard "Unix" pid file.
426 void create_pid_file(char *dir, const char *progname, int port)
428 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
432 POOLMEM *fname = get_pool_memory(PM_FNAME);
435 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
436 if (stat(fname, &statp) == 0) {
437 /* File exists, see what we have */
439 if ((pidfd = open(fname, O_RDONLY|O_BINARY, 0)) < 0 ||
440 read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
441 sscanf(pidbuf, "%d", &oldpid) != 1) {
442 Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname, strerror(errno));
444 /* See if other Bacula is still alive */
445 if (kill(oldpid, 0) != -1 || errno != ESRCH) {
446 Emsg3(M_ERROR_TERM, 0, _("%s is already running. pid=%d\nCheck file %s\n"),
447 progname, oldpid, fname);
449 /* He is not alive, so take over file ownership */
450 unlink(fname); /* remove stale pid file */
452 /* Create new pid file */
453 if ((pidfd = open(fname, O_CREAT|O_TRUNC|O_WRONLY|O_BINARY, 0640)) >= 0) {
454 len = sprintf(pidbuf, "%d\n", (int)getpid());
455 write(pidfd, pidbuf, len);
457 del_pid_file_ok = TRUE; /* we created it so we can delete it */
459 Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname, strerror(errno));
461 free_pool_memory(fname);
467 * Delete the pid file if we created it
469 int delete_pid_file(char *dir, const char *progname, int port)
471 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
472 POOLMEM *fname = get_pool_memory(PM_FNAME);
474 if (!del_pid_file_ok) {
475 free_pool_memory(fname);
478 del_pid_file_ok = FALSE;
479 Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
481 free_pool_memory(fname);
489 uint64_t last_jobs_addr;
490 uint64_t reserved[20];
493 static struct s_state_hdr state_hdr = {
509 #define lseek _lseeki64
511 #define O_BINARY _O_BINARY
515 * Open and read the state file for the daemon
517 void read_state_file(char *dir, const char *progname, int port)
522 POOLMEM *fname = get_pool_memory(PM_FNAME);
523 struct s_state_hdr hdr;
524 int hdr_size = sizeof(hdr);
526 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
527 /* If file exists, see what we have */
528 // Dmsg1(10, "O_BINARY=%d\n", O_BINARY);
529 if ((sfd = open(fname, O_RDONLY|O_BINARY)) < 0) {
530 Dmsg3(010, "Could not open state file. sfd=%d size=%d: ERR=%s\n",
531 sfd, sizeof(hdr), strerror(errno));
534 if ((stat=read(sfd, &hdr, hdr_size)) != hdr_size) {
535 Dmsg4(010, "Could not read state file. sfd=%d stat=%d size=%d: ERR=%s\n",
536 sfd, (int)stat, hdr_size, strerror(errno));
539 if (hdr.version != state_hdr.version) {
540 Dmsg2(010, "Bad hdr version. Wanted %d got %d\n",
541 state_hdr.version, hdr.version);
545 if (strcmp(hdr.id, state_hdr.id) != 0) {
546 Dmsg0(000, "State file header id invalid.\n");
549 // Dmsg1(010, "Read header of %d bytes.\n", sizeof(hdr));
550 if (!read_last_jobs_list(sfd, hdr.last_jobs_addr)) {
561 free_pool_memory(fname);
565 * Write the state file
567 void write_state_file(char *dir, const char *progname, int port)
571 POOLMEM *fname = get_pool_memory(PM_FNAME);
573 Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
574 /* Create new state file */
576 if ((sfd = open(fname, O_CREAT|O_WRONLY|O_BINARY, 0640)) < 0) {
578 Dmsg2(000, "Could not create state file. %s ERR=%s\n", fname, be.strerror());
579 Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, be.strerror());
582 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
584 Dmsg1(000, "Write hdr error: ERR=%s\n", be.strerror());
587 // Dmsg1(010, "Wrote header of %d bytes\n", sizeof(state_hdr));
588 state_hdr.last_jobs_addr = sizeof(state_hdr);
589 state_hdr.reserved[0] = write_last_jobs_list(sfd, state_hdr.last_jobs_addr);
590 // Dmsg1(010, "write last job end = %d\n", (int)state_hdr.reserved[0]);
591 if (lseek(sfd, 0, SEEK_SET) < 0) {
593 Dmsg1(000, "lseek error: ERR=%s\n", be.strerror());
596 if (write(sfd, &state_hdr, sizeof(state_hdr)) != sizeof(state_hdr)) {
598 Pmsg1(000, _("Write final hdr error: ERR=%s\n"), be.strerror());
602 // Dmsg1(010, "rewrote header = %d\n", sizeof(state_hdr));
610 free_pool_memory(fname);
615 * Drop to privilege new userid and new gid if non-NULL
617 void drop(char *uid, char *gid)
624 if ((group = getgrnam(gid)) == NULL) {
625 Emsg1(M_ERROR_TERM, 0, _("Could not find specified group: %s\n"), gid);
627 if (setgid(group->gr_gid)) {
628 Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
630 gr_list[0] = group->gr_gid;
631 if (setgroups(1, gr_list)) {
632 Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
639 struct passwd *passw;
640 if ((passw = getpwnam(uid)) == NULL) {
641 Emsg1(M_ERROR_TERM, 0, _("Could not find specified userid: %s\n"), uid);
643 if (setuid(passw->pw_uid)) {
644 Emsg1(M_ERROR_TERM, 0, _("Could not set specified userid: %s\n"), uid);
652 /* BSDI does not have this. This is a *poor* simulation */
655 strtoll(const char *ptr, char **endptr, int base)
657 return (long long int)strtod(ptr, endptr);
662 * Bacula's implementation of fgets(). The difference is that it handles
663 * being interrupted by a signal (e.g. a SIGCHLD).
666 char *bfgets(char *s, int size, FILE *fd)
671 for (int i=0; i < size-1; i++) {
675 } while (ch == -1 && (errno == EINTR || errno == EAGAIN));
685 if (ch == '\r') { /* Support for Mac/Windows file format */
687 if (ch == '\n') { /* Windows (\r\n) */
691 else { /* Mac (\r only) */
692 (void)ungetc(ch, fd); /* Push next character back to fd */
704 * Make a "unique" filename. It is important that if
705 * called again with the same "what" that the result
706 * will be identical. This allows us to use the file
707 * without saving its name, and re-generate the name
708 * so that it can be deleted.
710 void make_unique_filename(POOLMEM **name, int Id, char *what)
712 Mmsg(name, "%s/%s.%s.%d.tmp", working_directory, my_name, what, Id);