2 * util.c miscellaneous utility subroutines for Bacula
10 Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
12 This program is free software; you can redistribute it and/or
13 modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation; either version 2 of
15 the License, or (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU General Public
23 License along with this program; if not, write to the Free
24 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
31 #include "findlib/find.h"
34 * Various Bacula Utility subroutines
38 /* Return true of buffer has all zero bytes */
39 int is_buf_zero(char *buf, int len)
41 uint64_t *ip = (uint64_t *)buf;
43 int i, len64, done, rem;
45 /* Optimize by checking uint64_t for zero */
46 len64 = len >> sizeof(uint64_t);
47 for (i=0; i < len64; i++) {
52 done = len64 << sizeof(uint64_t); /* bytes already checked */
55 for (i = 0; i < rem; i++) {
64 /* Convert a string in place to lower case */
69 *str = tolower((int)(*str));
74 /* Convert spaces to non-space character.
75 * This makes scanf of fields containing spaces easier.
78 bash_spaces(char *str)
87 /* Convert non-space characters (0x1) back into spaces */
89 unbash_spaces(char *str)
98 /* Strip any trailing junk from the command */
99 void strip_trailing_junk(char *cmd)
102 p = cmd + strlen(cmd) - 1;
104 /* strip trailing junk from command */
105 while ((p >= cmd) && (*p == '\n' || *p == '\r' || *p == ' '))
109 /* Strip any trailing slashes from a directory path */
110 void strip_trailing_slashes(char *dir)
113 p = dir + strlen(dir) - 1;
115 /* strip trailing slashes */
116 while ((p >= dir) && (*p == '/'))
122 * Returns: 0 on failure (EOF)
124 * new address in passed parameter
126 int skip_spaces(char **msg)
132 while (*p && *p == ' ') {
141 * Returns: 0 on failure (EOF)
143 * new address in passed parameter
145 int skip_nonspaces(char **msg)
152 while (*p && *p != ' ') {
159 /* folded search for string - case insensitive */
161 fstrsch(char *a, char *b) /* folded case search */
163 register char *s1,*s2;
164 register char c1, c2;
168 while (*s1) { /* do it the fast way */
169 if ((*s1++ | 0x20) != (*s2++ | 0x20))
170 return 0; /* failed */
172 while (*a) { /* do it over the correct slow way */
173 if (B_ISUPPER(c1 = *a)) {
174 c1 = tolower((int)c1);
176 if (B_ISUPPER(c2 = *b)) {
177 c2 = tolower((int)c2);
189 char *encode_time(time_t time, char *buf)
194 if (localtime_r(&time, &tm)) {
195 n = sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d",
196 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
197 tm.tm_hour, tm.tm_min, tm.tm_sec);
203 * Concatenate a string (str) onto a pool memory buffer pm
205 void pm_strcat(POOLMEM **pm, char *str)
207 int pmlen = strlen(*pm);
208 int len = strlen(str) + 1;
210 *pm = check_pool_memory_size(*pm, pmlen + len);
211 memcpy(*pm+pmlen, str, len);
216 * Copy a string (str) into a pool memory buffer pm
218 void pm_strcpy(POOLMEM **pm, char *str)
220 int len = strlen(str) + 1;
222 *pm = check_pool_memory_size(*pm, len);
223 memcpy(*pm, str, len);
228 * Convert a JobStatus code into a human readable form
230 void jobstatus_to_ascii(int JobStatus, char *msg, int maxlen)
232 char *termstat, jstat[2];
239 case JS_ErrorTerminated:
240 termstat = _("Error");
243 termstat = _("Non-fatal error");
246 termstat = _("Canceled");
249 termstat = _("Verify differences");
252 jstat[0] = last_job.JobStatus;
257 bstrncpy(msg, termstat, maxlen);
261 * Convert Job Termination Status into a string
263 char *job_status_to_str(int stat)
271 case JS_ErrorTerminated:
276 str = _("Fatal Error");
282 str = _("Differences");
285 str = _("Unknown term code");
293 * Convert Job Type into a string
295 char *job_type_to_str(int type)
313 str = _("Unknown Type");
320 * Convert Job Level into a string
322 char *job_level_to_str(int level)
331 str = _("Incremental");
334 str = _("Differential");
339 case L_VERIFY_CATALOG:
340 str = _("Verify Catalog");
343 str = _("Verify Init Catalog");
345 case L_VERIFY_VOLUME_TO_CATALOG:
346 str = _("Verify Volume to Catalog");
349 str = _("Verify Data");
352 str = _("Unknown Job Level");
359 /***********************************************************************
360 * Encode the mode bits into a 10 character string like LS does
361 ***********************************************************************/
363 char *encode_mode(mode_t mode, char *buf)
367 *cp++ = S_ISDIR(mode) ? 'd' : S_ISBLK(mode) ? 'b' : S_ISCHR(mode) ? 'c' :
368 S_ISLNK(mode) ? 'l' : S_ISFIFO(mode) ? 'f' : S_ISSOCK(mode) ? 's' : '-';
369 *cp++ = mode & S_IRUSR ? 'r' : '-';
370 *cp++ = mode & S_IWUSR ? 'w' : '-';
371 *cp++ = (mode & S_ISUID
372 ? (mode & S_IXUSR ? 's' : 'S')
373 : (mode & S_IXUSR ? 'x' : '-'));
374 *cp++ = mode & S_IRGRP ? 'r' : '-';
375 *cp++ = mode & S_IWGRP ? 'w' : '-';
376 *cp++ = (mode & S_ISGID
377 ? (mode & S_IXGRP ? 's' : 'S')
378 : (mode & S_IXGRP ? 'x' : '-'));
379 *cp++ = mode & S_IROTH ? 'r' : '-';
380 *cp++ = mode & S_IWOTH ? 'w' : '-';
381 *cp++ = (mode & S_ISVTX
382 ? (mode & S_IXOTH ? 't' : 'T')
383 : (mode & S_IXOTH ? 'x' : '-'));
389 int do_shell_expansion(char *name)
391 /* ****FIXME***** this should work for Win32 too */
402 char echout[PATH_MAX + 256];
404 static char meta[] = "~\\$[]*?`'<>\"";
408 /* Check if any meta characters are present */
410 for (i = 0; i < len; i++) {
411 if (strchr(name, meta[i])) {
419 /* If the filename appears to be a DOS filename,
420 convert all backward slashes \ to Unix path
421 separators / and insert a \ infront of spaces. */
423 if (len >= 3 && name[1] == ':' && name[2] == '\\') {
424 for (i=2; i<len; i++)
429 /* Pass string off to the shell for interpretation */
432 switch(pid = fork()) {
438 if ((shellcmd = getenv("SHELL")) == NULL) {
439 shellcmd = "/bin/sh";
441 close(1); dup(pfd[1]); /* attach pipes to stdin and stdout */
442 close(2); dup(pfd[1]);
443 for (i = 3; i < 32; i++) /* close everything else */
445 strcpy(echout, "echo "); /* form echo command */
446 bstrncat(echout, name, sizeof(echout));
447 execl(shellcmd, shellcmd, "-c", echout, NULL); /* give to shell */
448 exit(127); /* shouldn't get here */
450 default: /* parent */
451 /* read output from child */
453 i = read(pfd[0], echout, sizeof echout);
455 echout[--i] = 0; /* set end of string */
456 /* look for first line. */
458 if (echout[i] == '\n') {
459 echout[i] = 0; /* keep only first one */
463 /* wait for child to exit */
464 while ((wpid = wait(&waitstatus)) != pid && wpid != -1)
466 strcpy(name, echout);
470 close(pfd[0]); /* close pipe */
478 #if MSC | MSDOS | __WATCOMC__
480 char prefix[100], *env, *getenv();
482 /* Home directory reference? */
483 if (*name == '~' && (env=getenv("HOME"))) {
484 strcpy(prefix, env); /* copy HOME directory name */
485 name++; /* skip over ~ in name */
486 strcat(prefix, name);
487 name--; /* get back to beginning */
488 strcpy(name, prefix); /* move back into name */
496 /* MAKESESSIONKEY -- Generate session key with optional start
497 key. If mode is TRUE, the key will be
498 translated to a string, otherwise it is
499 returned as 16 binary bytes.
501 from SpeakFreely by John Walker */
503 void makeSessionKey(char *key, char *seed, int mode)
506 struct MD5Context md5c;
507 unsigned char md5key[16], md5key1[16];
515 /* The following creates a seed for the session key generator
516 based on a collection of volatile and environment-specific
517 information unlikely to be vulnerable (as a whole) to an
518 exhaustive search attack. If one of these items isn't
519 available on your machine, replace it with something
520 equivalent or, if you like, just delete it. */
522 sprintf(s + strlen(s), "%lu", (unsigned long) getpid());
523 sprintf(s + strlen(s), "%lu", (unsigned long) getppid());
524 getcwd(s + strlen(s), 256);
525 sprintf(s + strlen(s), "%lu", (unsigned long) clock());
526 sprintf(s + strlen(s), "%lu", (unsigned long) time(NULL));
528 sysinfo(SI_HW_SERIAL,s + strlen(s), 12);
530 #ifdef HAVE_GETHOSTID
531 sprintf(s + strlen(s), "%lu", (unsigned long) gethostid());
533 #ifdef HAVE_GETDOMAINNAME
534 getdomainname(s + strlen(s), 256);
536 gethostname(s + strlen(s), 256);
537 sprintf(s + strlen(s), "%u", (unsigned)getuid());
538 sprintf(s + strlen(s), "%u", (unsigned)getgid());
540 MD5Update(&md5c, (unsigned char *)s, strlen(s));
541 MD5Final(md5key, &md5c);
542 sprintf(s + strlen(s), "%lu", (unsigned long) ((time(NULL) + 65121) ^ 0x375F));
544 MD5Update(&md5c, (unsigned char *)s, strlen(s));
545 MD5Final(md5key1, &md5c);
546 #define nextrand (md5key[j] ^ md5key1[j])
548 for (j = k = 0; j < 16; j++) {
549 unsigned char rb = nextrand;
551 #define Rad16(x) ((x) + 'A')
552 key[k++] = Rad16((rb >> 4) & 0xF);
553 key[k++] = Rad16(rb & 0xF);
561 for (j = 0; j < 16; j++) {
571 * Edit job codes into main command line
574 * %t = Job type (Backup, ...)
580 * %d = Director's name
582 * omsg = edited output message
583 * imsg = input string containing edit codes (%x)
584 * to = recepients list
587 POOLMEM *edit_job_codes(void *mjcr, char *omsg, char *imsg, char *to)
591 JCR *jcr = (JCR *)mjcr;
594 Dmsg1(200, "edit_job_codes: %s\n", imsg);
595 for (p=imsg; *p; p++) {
602 str = jcr->client_name;
608 str = my_name; /* Director's name */
611 str = job_status_to_str(jcr->JobStatus);
614 sprintf(add, "%d", jcr->JobId);
617 case 'j': /* Job name */
621 str = job_level_to_str(jcr->JobLevel);
627 str = job_type_to_str(jcr->JobType);
641 Dmsg1(1200, "add_str %s\n", str);
642 pm_strcat(&omsg, str);
643 Dmsg1(1200, "omsg=%s\n", omsg);
649 * Return next argument from command line. Note, this
650 * routine is destructive.
652 char *next_arg(char **s)
657 /* skip past spaces to next arg */
658 for (p=*s; *p && *p == ' '; ) {
661 Dmsg1(400, "Next arg=%s\n", p);
662 for (n = q = p; *p ; ) {
672 if (*p == '"') { /* start or end of quote */
674 p++; /* skip quote */
682 if (!in_quote && *p == ' ') { /* end of field */
690 Dmsg2(400, "End arg=%s next=%s\n", n, p);
695 * This routine parses the input command line.
696 * It makes a copy in args, then builds an
697 * argc, argv like list where
699 * argc = count of arguments
700 * argk[i] = argument keyword (part preceding =)
701 * argv[i] = argument value (part after =)
703 * example: arg1 arg2=abc arg3=
714 void parse_command_args(POOLMEM *cmd, POOLMEM *args, int *argc,
715 char **argk, char **argv)
720 len = strlen(cmd) + 1;
721 args = check_pool_memory_size(args, len);
722 bstrncpy(args, cmd, len);
723 strip_trailing_junk(args);
726 /* Pick up all arguments */
727 while (*argc < MAX_CMD_ARGS) {
731 argv[(*argc)++] = NULL;
736 /* Separate keyword and value */
737 for (int i=0; i < *argc; i++) {
738 p = strchr(argk[i], '=');
740 *p++ = 0; /* terminate keyword and point to value */
741 /* Unquote quoted values */
743 for (n = q = ++p; *p && *p != '"'; ) {
749 *q = 0; /* terminate string */
750 p = n; /* point to string */
752 if (strlen(p) > MAX_NAME_LENGTH-1) {
753 p[MAX_NAME_LENGTH-1] = 0; /* truncate to max len */
756 argv[i] = p; /* save ptr to value or NULL */
759 for (i=0; i<argc; i++) {
760 Dmsg3(000, "Arg %d: kw=%s val=%s\n", i, argk[i], argv[i]?argv[i]:"NULL");