git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/bsys.c

   1 /*
   2  * Miscellaneous Bacula memory and thread safe routines
   3  *   Generally, these are interfaces to system or standard
   4  *   library routines.
   5  *
   6  *  Bacula utility functions are in util.c
   7  *
   8  *   Version $Id$
   9  */
  10 /*
  11    Copyright (C) 2000-2003 Kern Sibbald and John Walker
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of
  16    the License, or (at your option) any later version.
  17
  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 GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public
  24    License along with this program; if not, write to the Free
  25    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  26    MA 02111-1307, USA.
  27
  28  */
  29
  30
  31 #include "bacula.h"
  32 #ifdef HAVE_PWD_H
  33 #include <pwd.h>
  34 #endif
  35 #ifdef HAVE_GRP_H
  36 #include <grp.h>
  37 #endif
  38
  39 /*
  40  * Guarantee that the string is properly terminated */
  41 char *bstrncpy(char *dest, const char *src, int maxlen)
  42 {
  43    strncpy(dest, src, maxlen-1);
  44    dest[maxlen-1] = 0;
  45    return dest;
  46 }
  47
  48 char *bstrncat(char *dest, const char *src, int maxlen)
  49 {
  50    strncat(dest, src, maxlen-1);
  51    dest[maxlen-1] = 0;
  52    return dest;
  53 }
  54
  55
  56 #ifndef DEBUG
  57 void *bmalloc(size_t size)
  58 {
  59   void *buf;
  60
  61   buf = malloc(size);
  62   if (buf == NULL) {
  63      Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
  64   }
  65   return buf;
  66 }
  67 #endif
  68
  69 void *b_malloc(const char *file, int line, size_t size)
  70 {
  71   void *buf;
  72
  73 #ifdef SMARTALLOC
  74   buf = sm_malloc(file, line, size);
  75 #else
  76   buf = malloc(size);
  77 #endif
  78   if (buf == NULL) {
  79      e_msg(file, line, M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
  80   }
  81   return buf;
  82 }
  83
  84
  85 void *brealloc (void *buf, size_t size)
  86 {
  87    buf = realloc(buf, size);
  88    if (buf == NULL) {
  89       Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
  90    }
  91    return buf;
  92 }
  93
  94
  95 void *bcalloc (size_t size1, size_t size2)
  96 {
  97   void *buf;
  98
  99    buf = calloc(size1, size2);
 100    if (buf == NULL) {
 101       Emsg1(M_ABORT, 0, _("Out of memory: ERR=%s\n"), strerror(errno));
 102    }
 103    return buf;
 104 }
 105
 106
 107 #define BIG_BUF 5000
 108 /*
 109  * Implement snprintf
 110  */
 111 int bsnprintf(char *str, int32_t size, const char *fmt,  ...)
 112 {
 113 #ifdef HAVE_VSNPRINTF
 114    va_list   arg_ptr;
 115    int len;
 116
 117    va_start(arg_ptr, fmt);
 118    len = vsnprintf(str, size, fmt, arg_ptr);
 119    va_end(arg_ptr);
 120    str[size-1] = 0;
 121    return len;
 122
 123 #else
 124
 125    va_list   arg_ptr;
 126    int len;
 127    char *buf;
 128
 129    buf = get_memory(BIG_BUF);
 130    va_start(arg_ptr, fmt);
 131    len = vsprintf(buf, fmt, arg_ptr);
 132    va_end(arg_ptr);
 133    if (len >= BIG_BUF) {
 134       Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
 135    }
 136    memcpy(str, buf, size);
 137    str[size-1] = 0;
 138    free_memory(buf);
 139    return len;
 140 #endif
 141 }
 142
 143 /*
 144  * Implement vsnprintf()
 145  */
 146 int bvsnprintf(char *str, int32_t size, const char  *format, va_list ap)
 147 {
 148 #ifdef HAVE_VSNPRINTF
 149    int len;
 150    len = vsnprintf(str, size, format, ap);
 151    str[size-1] = 0;
 152    return len;
 153
 154 #else
 155
 156    int len;
 157    char *buf;
 158    buf = get_memory(BIG_BUF);
 159    len = vsprintf(buf, format, ap);
 160    if (len >= BIG_BUF) {
 161       Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
 162    }
 163    memcpy(str, buf, size);
 164    str[size-1] = 0;
 165    free_memory(buf);
 166    return len;
 167 #endif
 168 }
 169
 170 #ifndef HAVE_LOCALTIME_R
 171
 172 struct tm *localtime_r(const time_t *timep, struct tm *tm)
 173 {
 174     static pthread_mutex_t mutex;
 175     static int first = 1;
 176     struct tm *ltm;
 177
 178     if (first) {
 179        pthread_mutex_init(&mutex, NULL);
 180        first = 0;
 181     }
 182     P(mutex);
 183     ltm = localtime(timep);
 184     if (ltm) {
 185        memcpy(tm, ltm, sizeof(struct tm));
 186     }
 187     V(mutex);
 188     return ltm ? tm : NULL;
 189 }
 190 #endif /* HAVE_LOCALTIME_R */
 191
 192 #ifndef HAVE_READDIR_R
 193 #ifndef HAVE_WIN32
 194 #include <dirent.h>
 195
 196 int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
 197 {
 198     static pthread_mutex_t mutex;
 199     static int first = 1;
 200     struct dirent *ndir;
 201     int stat;
 202
 203     if (first) {
 204        pthread_mutex_init(&mutex, NULL);
 205        first = 0;
 206     }
 207     P(mutex);
 208     errno = 0;
 209     ndir = readdir(dirp);
 210     stat = errno;
 211     if (ndir) {
 212        memcpy(entry, ndir, sizeof(struct dirent));
 213        strcpy(entry->d_name, ndir->d_name);
 214        *result = entry;
 215     } else {
 216        *result = NULL;
 217     }
 218     V(mutex);
 219     return stat;
 220
 221 }
 222 #endif
 223 #endif /* HAVE_READDIR_R */
 224
 225 #ifdef xxxxxxxxxx_STRERROR_R
 226 int strerror_r(int errnum, char *buf, size_t bufsiz)
 227 {
 228     static pthread_mutex_t mutex;
 229     static int first = 1;
 230     int stat = 0;
 231     char *msg;
 232
 233     if (first) {
 234        pthread_mutex_init(&mutex, NULL);
 235        first = 0;
 236     }
 237     P(mutex);
 238
 239     msg = strerror(errnum);
 240     if (!msg) {
 241        msg = _("Bad errno");
 242        stat = -1;
 243     }
 244     bstrncpy(buf, msg, bufsiz);
 245     V(mutex);
 246     return stat;
 247 }
 248 #endif /* HAVE_STRERROR_R */
 249
 250 /*
 251  * These are mutex routines that do error checking
 252  *  for deadlock and such.  Normally not turned on.
 253  */
 254 #ifdef DEBUG_MUTEX
 255 void _p(char *file, int line, pthread_mutex_t *m)
 256 {
 257    int errstat;
 258    if ((errstat = pthread_mutex_trylock(m))) {
 259       e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock.\n"));
 260       /* We didn't get the lock, so do it definitely now */
 261       if ((errstat=pthread_mutex_lock(m))) {
 262          e_msg(file, line, M_ABORT, 0, _("Mutex lock failure. ERR=%s\n"),
 263                strerror(errstat));
 264       } else {
 265          e_msg(file, line, M_ERROR, 0, _("Possible mutex deadlock resolved.\n"));
 266       }
 267
 268    }
 269 }
 270
 271 void _v(char *file, int line, pthread_mutex_t *m)
 272 {
 273    int errstat;
 274
 275    if ((errstat=pthread_mutex_trylock(m)) == 0) {
 276       e_msg(file, line, M_ERROR, 0, _("Mutex unlock not locked. ERR=%s\n"),
 277            strerror(errstat));
 278     }
 279     if ((errstat=pthread_mutex_unlock(m))) {
 280        e_msg(file, line, M_ABORT, 0, _("Mutex unlock failure. ERR=%s\n"),
 281               strerror(errstat));
 282     }
 283 }
 284 #endif /* DEBUG_MUTEX */
 285
 286 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
 287 static int del_pid_file_ok = FALSE;
 288 #endif
 289
 290 /*
 291  * Create a standard "Unix" pid file.
 292  */
 293 void create_pid_file(char *dir, const char *progname, int port)
 294 {
 295 #if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
 296    int pidfd, len;
 297    int oldpid;
 298    char  pidbuf[20];
 299    POOLMEM *fname = get_pool_memory(PM_FNAME);
 300    struct stat statp;
 301
 302    Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
 303    if (stat(mp_chr(fname), &statp) == 0) {
 304       /* File exists, see what we have */
 305       *pidbuf = 0;
 306       if ((pidfd = open(mp_chr(fname), O_RDONLY)) < 0 ||
 307            read(pidfd, &pidbuf, sizeof(pidbuf)) < 0 ||
 308            sscanf(pidbuf, "%d", &oldpid) != 1) {
 309          Emsg2(M_ERROR_TERM, 0, _("Cannot open pid file. %s ERR=%s\n"), fname, strerror(errno));
 310       }
 311       /* See if other Bacula is still alive */
 312       if (kill(oldpid, 0) != -1 || errno != ESRCH) {
 313          Emsg3(M_ERROR_TERM, 0, _("%s is already running. pid=%d\nCheck file %s\n"),
 314                progname, oldpid, fname);
 315       }
 316       /* He is not alive, so take over file ownership */
 317       unlink(mp_chr(fname));                  /* remove stale pid file */
 318    }
 319    /* Create new pid file */
 320    if ((pidfd = open(mp_chr(fname), O_CREAT | O_TRUNC | O_WRONLY, 0644)) >= 0) {
 321       len = sprintf(pidbuf, "%d\n", (int)getpid());
 322       write(pidfd, pidbuf, len);
 323       close(pidfd);
 324       del_pid_file_ok = TRUE;         /* we created it so we can delete it */
 325    } else {
 326       Emsg2(M_ERROR_TERM, 0, _("Could not open pid file. %s ERR=%s\n"), fname, strerror(errno));
 327    }
 328    free_pool_memory(fname);
 329 #endif
 330 }
 331
 332
 333 /*
 334  * Delete the pid file if we created it
 335  */
 336 int delete_pid_file(char *dir, const char *progname, int port)
 337 {
 338 #if !defined(HAVE_CYGWIN)  && !defined(HAVE_WIN32)
 339    POOLMEM *fname = get_pool_memory(PM_FNAME);
 340
 341    if (!del_pid_file_ok) {
 342       free_pool_memory(fname);
 343       return 0;
 344    }
 345    del_pid_file_ok = FALSE;
 346    Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
 347    unlink(mp_chr(fname));
 348    free_pool_memory(fname);
 349 #endif
 350    return 1;
 351 }
 352
 353 struct s_state_hdr {
 354    char id[14];
 355    int32_t version;
 356    uint64_t last_jobs_addr;
 357    uint64_t reserved[20];
 358 };
 359
 360 static struct s_state_hdr state_hdr = {
 361    "Bacula State\n",
 362    3,
 363    0
 364 };
 365
 366 /*
 367  * Open and read the state file for the daemon
 368  */
 369 void read_state_file(char *dir, const char *progname, int port)
 370 {
 371    int sfd;
 372    POOLMEM *fname = get_pool_memory(PM_FNAME);
 373    struct s_state_hdr hdr;
 374
 375    Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
 376    /* If file exists, see what we have */
 377    if ((sfd = open(mp_chr(fname), O_RDONLY, 0)) < 0 ||
 378        read(sfd, &hdr, sizeof(hdr)) < 0 ||
 379        hdr.version != state_hdr.version) {
 380       Dmsg2(000, "Could not open or read state file. sfd=%d: ERR=%s\n",
 381                     sfd, strerror(errno));
 382       goto bail_out;
 383    }
 384    hdr.id[13] = 0;
 385    if (strcmp(hdr.id, state_hdr.id) != 0) {
 386       Dmsg0(000, "State file header invalid.\n");
 387       goto bail_out;
 388    }
 389    read_last_jobs_list(sfd, hdr.last_jobs_addr);
 390 bail_out:
 391    if (sfd >= 0) {
 392       close(sfd);
 393    }
 394    free_pool_memory(fname);
 395 }
 396
 397 /*
 398  * Write the state file
 399  */
 400 void write_state_file(char *dir, const char *progname, int port)
 401 {
 402    int sfd;
 403    POOLMEM *fname = get_pool_memory(PM_FNAME);
 404
 405    Mmsg(&fname, "%s/%s.%d.state", dir, progname, port);
 406    /* Create new state file */
 407    if ((sfd = open(mp_chr(fname), O_CREAT | O_TRUNC | O_WRONLY, 0640)) < 0) {
 408       Dmsg2(000, _("Could not create state file. %s ERR=%s\n"), fname, strerror(errno));
 409       Emsg2(M_ERROR, 0, _("Could not create state file. %s ERR=%s\n"), fname, strerror(errno));
 410       goto bail_out;
 411    }
 412    if (write(sfd, &state_hdr, sizeof(state_hdr)) < 0) {
 413       Dmsg1(000, "Write error: ERR=%s\n", strerror(errno));
 414       goto bail_out;
 415    }
 416    state_hdr.last_jobs_addr = sizeof(state_hdr);
 417    state_hdr.reserved[0] = write_last_jobs_list(sfd, state_hdr.last_jobs_addr);
 418    if (lseek(sfd, 0, SEEK_SET) < 0) {
 419       Dmsg1(000, "lseek error: ERR=%s\n", strerror(errno));
 420       goto bail_out;
 421    }
 422    write(sfd, &state_hdr, sizeof(state_hdr));
 423 bail_out:
 424    if (sfd >= 0) {
 425       close(sfd);
 426    }
 427    free_pool_memory(fname);
 428 }
 429
 430
 431 /*
 432  * Drop to privilege new userid and new gid if non-NULL
 433  */
 434 void drop(char *uid, char *gid)
 435 {
 436 #ifdef HAVE_GRP_H
 437    if (gid) {
 438       struct group *group;
 439       gid_t gr_list[1];
 440
 441       if ((group = getgrnam(gid)) == NULL) {
 442          Emsg1(M_ERROR_TERM, 0, _("Could not find specified group: %s\n"), gid);
 443       }
 444       if (setgid(group->gr_gid)) {
 445          Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
 446       }
 447       gr_list[0] = group->gr_gid;
 448       if (setgroups(1, gr_list)) {
 449          Emsg1(M_ERROR_TERM, 0, _("Could not set specified group: %s\n"), gid);
 450       }
 451    }
 452 #endif
 453
 454 #ifdef HAVE_PWD_H
 455    if (uid) {
 456       struct passwd *passw;
 457       if ((passw = getpwnam(uid)) == NULL) {
 458          Emsg1(M_ERROR_TERM, 0, _("Could not find specified userid: %s\n"), uid);
 459       }
 460       if (setuid(passw->pw_uid)) {
 461          Emsg1(M_ERROR_TERM, 0, _("Could not set specified userid: %s\n"), uid);
 462       }
 463    }
 464 #endif
 465
 466 }
 467
 468 static pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
 469 static pthread_cond_t timer = PTHREAD_COND_INITIALIZER;
 470
 471 /*
 472  * This routine will sleep (sec, microsec).  Note, however, that if a
 473  *   signal occurs, it will return early.  It is up to the caller
 474  *   to recall this routine if he/she REALLY wants to sleep the
 475  *   requested time.
 476  */
 477 int bmicrosleep(time_t sec, long usec)
 478 {
 479    struct timespec timeout;
 480    struct timeval tv;
 481    struct timezone tz;
 482    int stat;
 483
 484    timeout.tv_sec = sec;
 485    timeout.tv_nsec = usec * 1000;
 486
 487 #ifdef HAVE_NANOSLEEP
 488    stat = nanosleep(&timeout, NULL);
 489    if (!(stat < 0 && errno == ENOSYS)) {
 490       return stat;
 491    }
 492    /* If we reach here it is because nanosleep is not supported by the OS */
 493 #endif
 494
 495    /* Do it the old way */
 496    gettimeofday(&tv, &tz);
 497    timeout.tv_nsec += tv.tv_usec * 1000;
 498    timeout.tv_sec += tv.tv_sec;
 499    while (timeout.tv_nsec >= 1000000000) {
 500       timeout.tv_nsec -= 1000000000;
 501       timeout.tv_sec++;
 502    }
 503
 504    Dmsg1(200, "pthread_cond_timedwait sec=%d\n", timeout.tv_sec);
 505    /* Note, this unlocks mutex during the sleep */
 506    P(timer_mutex);
 507    stat = pthread_cond_timedwait(&timer, &timer_mutex, &timeout);
 508    Dmsg1(200, "pthread_cond_timedwait stat=%d\n", stat);
 509    V(timer_mutex);
 510    return stat;
 511 }
 512
 513 /* BSDI does not have this.  This is a *poor* simulation */
 514 #ifndef HAVE_STRTOLL
 515 long long int
 516 strtoll(const char *ptr, char **endptr, int base)
 517 {
 518    return (long long int)strtod(ptr, endptr);
 519 }
 520 #endif
 521
 522 /*
 523  * Bacula's implementation of fgets(). The difference is that it handles
 524  *   being interrupted by a signal (e.g. a SIGCHLD).
 525  */
 526 #undef fgetc
 527 char *bfgets(char *s, int size, FILE *fd)
 528 {
 529    char *p = s;
 530    int ch;
 531    *p = 0;
 532    for (int i=0; i < size-1; i++) {
 533       do {
 534          errno = 0;
 535          ch = fgetc(fd);
 536       } while (ch == -1 && (errno == EINTR || errno == EAGAIN));
 537       if (ch == -1) {
 538          if (i == 0) {
 539             return NULL;
 540          } else {
 541             return s;
 542          }
 543       }
 544       *p++ = ch;
 545       *p = 0;
 546       if (ch == '\n') {
 547          break;
 548       }
 549    }
 550    return s;
 551 }
 552
 553 /*
 554  * Make a "unique" filename.  It is important that if
 555  *   called again with the same "what" that the result
 556  *   will be identical. This allows us to use the file
 557  *   without saving its name, and re-generate the name
 558  *   so that it can be deleted.
 559  */
 560 void make_unique_filename(POOLMEM **name, int Id, char *what)
 561 {
 562    Mmsg(name, "%s/%s.%s.%d.tmp", working_directory, my_name, what, Id);
 563 }