/*
- * util.c miscellaneous utility subroutines for Bacula
- *
- * Kern Sibbald, MM
- *
- * Version $Id$
- */
-/*
- Copyright (C) 2000-2006 Kern Sibbald
+ Bacula(R) - The Network Backup Solution
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License
- version 2 as amended with additional clauses defined in the
- file LICENSE in the main source directory.
+ Copyright (C) 2000-2017 Kern Sibbald
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- the file LICENSE for additional details.
+ The original author of Bacula is Kern Sibbald, with contributions
+ from many others, a complete list can be found in the file AUTHORS.
+ You may use this file and others of this release according to the
+ license defined in the LICENSE file, which includes the Affero General
+ Public License, v3.0 ("AGPLv3") and some additional permissions and
+ terms pursuant to its AGPLv3 Section 7.
+
+ This notice must be preserved when any source code is
+ conveyed and/or propagated.
+
+ Bacula(R) is a registered trademark of Kern Sibbald.
+*/
+/*
+ * util.c miscellaneous utility subroutines for Bacula
+ *
+ * Kern Sibbald, MM
*/
#include "bacula.h"
*
*/
+bool is_null(const void *ptr)
+{
+ return ptr == NULL;
+}
+
/* Return true of buffer has all zero bytes */
-int is_buf_zero(char *buf, int len)
+bool is_buf_zero(const char *buf, int len)
{
uint64_t *ip;
- char *p;
+ const char *p;
int i, len64, done, rem;
if (buf[0] != 0) {
- return 0;
+ return false;
}
ip = (uint64_t *)buf;
/* Optimize by checking uint64_t for zero */
len64 = len / sizeof(uint64_t);
for (i=0; i < len64; i++) {
if (ip[i] != 0) {
- return 0;
+ return false;
}
}
done = len64 * sizeof(uint64_t); /* bytes already checked */
rem = len - done;
for (i = 0; i < rem; i++) {
if (p[i] != 0) {
- return 0;
+ return false;
}
}
- return 1;
+ return true;
+}
+
+/*
+ * Subroutine that cannot be suppressed by GCC 6.0
+ */
+void bmemzero(void *buf, size_t size)
+{
+ memset(buf, 0, size);
+ return;
}
void lcase(char *str)
{
while (*str) {
- if (B_ISUPPER(*str))
+ if (B_ISUPPER(*str)) {
*str = tolower((int)(*str));
+ }
str++;
}
}
}
}
-char *encode_time(time_t time, char *buf)
+char *encode_time(utime_t utime, char *buf)
{
struct tm tm;
int n = 0;
+ time_t time = utime;
#if defined(HAVE_WIN32)
/*
+static char hexatable[]="0123456789abcdef";
+
+/*
+ * do an hexadump of data[0:len] into buf[0:capacity]
+ * a space is inserted between every 4 bytes
+ * usage:
+ * char buf[10];
+ * Dmsg2("msglen=%d msg=%s", fd->msglen, hexdump(fd->msg, fd->msglen, buf, sizeof(buf));
+ * ==>
+ * msglen=36 msg=12345678 12345678
+ */
+char *hexdump(const char *data, int len, char *buf, int capacity, bool add_spaces)
+{
+ char *b=buf;
+ int i=0;
+ while (i<len && capacity>2) {
+ if (add_spaces && i>0 && i%4==0 ) {
+ *(b++)=' ';
+ capacity--;
+ }
+ if (capacity>2) {
+ *(b++)=hexatable[(data[i]&0xF0)>>4];
+ *(b++)=hexatable[data[i++]&0x0F];
+ }
+ capacity-=2;
+ }
+ *b='\0';
+ return buf;
+}
+
+/*
+ * do an ASCII dump of data[0:len] into buf[0:capacity]
+ * non printable chars are replaced by hexa "\xx"
+ * usage:
+ * char buf[10];
+ * Dmsg2("msglen=%d msg=%s", fd->msglen, asciidump(fd->msg, fd->msglen, buf, sizeof(buf));
+ * ==>
+ * msglen=5 msg=abcd\10
+ */
+char *asciidump(const char *data, int len, char *buf, int capacity)
+{
+ char *b=buf;
+ const unsigned char *p=(const unsigned char *)data;
+ if (!data) {
+ strncpy(buf, "<NULL>", capacity);
+ return buf;
+ }
+ while (len>0 && capacity>1) {
+ if (isprint(*p)) {
+ *(b++)=*(p++);
+ capacity--;
+ } else {
+ if (capacity>3) {
+ *(b++)='\\';
+ *(b++)=hexatable[((*p)&0xF0)>>4];
+ *(b++)=hexatable[(*(p++))&0x0F];
+ }
+ capacity-=3;
+ }
+ len--;
+ }
+ *b='\0';
+ return buf;
+}
+
+char *smartdump(const char *data, int len, char *buf, int capacity, bool *is_ascii)
+{
+ char *b=buf;
+ int l=len;
+ int c=capacity;
+ const unsigned char *p=(const unsigned char *)data;
+ if (!data) {
+ strncpy(buf, "<NULL>", capacity);
+ return buf;
+ }
+ if (is_ascii != NULL) {
+ *is_ascii = false;
+ }
+ while (l>0 && c>1) {
+ if (isprint(*p)) {
+ *(b++)=*(p++);
+ } else if (isspace(*p) || *p=='\0') {
+ *(b++)=' ';
+ p++;
+ } else {
+ return hexdump(data, len, buf, capacity);
+ }
+ c--;
+ l--;
+ }
+ *b='\0';
+ if (is_ascii != NULL) {
+ *is_ascii = true;
+ }
+ return buf;
+}
+
+/*
+ * check if x is a power two
+ */
+int is_power_of_two(uint64_t x)
+{
+ while ( x%2 == 0 && x > 1) {
+ x /= 2;
+ }
+ return (x == 1);
+}
+
/*
* Convert a JobStatus code into a human readable form
*/
case JS_Terminated:
jobstat = _("OK");
break;
+ case JS_Incomplete:
+ jobstat = _("Incomplete job");
+ break;
case JS_FatalError:
case JS_ErrorTerminated:
jobstat = _("Error");
case JS_Error:
jobstat = _("Non-fatal error");
break;
+ case JS_Warnings:
+ jobstat = _("OK -- with warnings");
+ break;
case JS_Canceled:
jobstat = _("Canceled");
break;
case JS_WaitPriority:
jobstat = _("Waiting on Priority");
break;
+ case JS_DataCommitting:
+ jobstat = _("SD committing Data");
+ break;
+ case JS_DataDespooling:
+ jobstat = _("SD despooling Data");
+ break;
+ case JS_AttrDespooling:
+ jobstat = _("SD despooling Attributes");
+ break;
+ case JS_AttrInserting:
+ jobstat = _("Dir inserting Attributes");
+ break;
default:
if (JobStatus == 0) {
bstrncpy(msg, jobstat, maxlen);
}
+/*
+ * Convert a JobStatus code into a human readable form - gui version
+ */
+void jobstatus_to_ascii_gui(int JobStatus, char *msg, int maxlen)
+{
+ const char *cnv = NULL;
+ switch (JobStatus) {
+ case JS_Terminated:
+ cnv = _("Completed successfully");
+ break;
+ case JS_Warnings:
+ cnv = _("Completed with warnings");
+ break;
+ case JS_ErrorTerminated:
+ cnv = _("Terminated with errors");
+ break;
+ case JS_FatalError:
+ cnv = _("Fatal error");
+ break;
+ case JS_Created:
+ cnv = _("Created, not yet running");
+ break;
+ case JS_Canceled:
+ cnv = _("Canceled by user");
+ break;
+ case JS_Differences:
+ cnv = _("Verify found differences");
+ break;
+ case JS_WaitFD:
+ cnv = _("Waiting for File daemon");
+ break;
+ case JS_WaitSD:
+ cnv = _("Waiting for Storage daemon");
+ break;
+ case JS_WaitPriority:
+ cnv = _("Waiting for higher priority jobs");
+ break;
+ case JS_AttrInserting:
+ cnv = _("Batch inserting file records");
+ break;
+ };
+
+ if (cnv) {
+ bstrncpy(msg, cnv, maxlen);
+ } else {
+ jobstatus_to_ascii(JobStatus, msg, maxlen);
+ }
+}
+
/*
* Convert Job Termination Status into a string
*/
-const char *job_status_to_str(int stat)
+const char *job_status_to_str(int status, int errors)
{
const char *str;
- switch (stat) {
+ switch (status) {
case JS_Terminated:
- str = _("OK");
+ if (errors > 0) {
+ str = _("OK -- with warnings");
+ } else {
+ str = _("OK");
+ }
+ break;
+ case JS_Warnings:
+ str = _("OK -- with warnings");
break;
case JS_ErrorTerminated:
case JS_Error:
case JS_Differences:
str = _("Differences");
break;
+ case JS_Created:
+ str = _("Created");
+ break;
+ case JS_Incomplete:
+ str = _("Incomplete");
+ break;
default:
str = _("Unknown term code");
break;
*/
const char *job_type_to_str(int type)
{
- const char *str;
+ const char *str = NULL;
switch (type) {
case JT_BACKUP:
str = _("Backup");
break;
+ case JT_MIGRATED_JOB:
+ str = _("Migrated Job");
+ break;
case JT_VERIFY:
str = _("Verify");
break;
case JT_RESTORE:
str = _("Restore");
break;
+ case JT_CONSOLE:
+ str = _("Console");
+ break;
+ case JT_SYSTEM:
+ str = _("System or Console");
+ break;
case JT_ADMIN:
str = _("Admin");
break;
- case JT_MIGRATE:
- str = _("Migrate");
+ case JT_ARCHIVE:
+ str = _("Archive");
+ break;
+ case JT_JOB_COPY:
+ str = _("Job Copy");
break;
case JT_COPY:
str = _("Copy");
break;
- default:
- str = _("Unknown Type");
+ case JT_MIGRATE:
+ str = _("Migrate");
+ break;
+ case JT_SCAN:
+ str = _("Scan");
break;
}
+ if (!str) {
+ str = _("Unknown Type");
+ }
return str;
}
+/* Convert ActionOnPurge to string (Truncate, Erase, Destroy)
+ */
+char *action_on_purge_to_string(int aop, POOL_MEM &ret)
+{
+ if (aop & ON_PURGE_TRUNCATE) {
+ pm_strcpy(ret, _("Truncate"));
+ }
+ if (!aop) {
+ pm_strcpy(ret, _("None"));
+ }
+ return ret.c_str();
+}
+
/*
* Convert Job Level into a string
*/
switch (level) {
case L_BASE:
str = _("Base");
+ break;
case L_FULL:
str = _("Full");
break;
case L_VERIFY_DATA:
str = _("Verify Data");
break;
+ case L_VIRTUAL_FULL:
+ str = _("Virtual Full");
+ break;
case L_NONE:
str = " ";
break;
return str;
}
+const char *volume_status_to_str(const char *status)
+{
+ int pos;
+ const char *vs[] = {
+ NT_("Append"), _("Append"),
+ NT_("Archive"), _("Archive"),
+ NT_("Disabled"), _("Disabled"),
+ NT_("Full"), _("Full"),
+ NT_("Used"), _("Used"),
+ NT_("Cleaning"), _("Cleaning"),
+ NT_("Purged"), _("Purged"),
+ NT_("Recycle"), _("Recycle"),
+ NT_("Read-Only"), _("Read-Only"),
+ NT_("Error"), _("Error"),
+ NULL, NULL};
+
+ if (status) {
+ for (pos = 0 ; vs[pos] ; pos += 2) {
+ if ( !strcmp(vs[pos],status) ) {
+ return vs[pos+1];
+ }
+ }
+ }
+
+ return _("Invalid volume status");
+}
+
/***********************************************************************
* Encode the mode bits into a 10 character string like LS does
return cp;
}
+#if defined(HAVE_WIN32)
+int do_shell_expansion(char *name, int name_len)
+{
+ char *src = bstrdup(name);
+
+ ExpandEnvironmentStrings(src, name, name_len);
+
+ free(src);
+ return 1;
+}
+#else
int do_shell_expansion(char *name, int name_len)
{
static char meta[] = "~\\$[]*?`'<>\"";
}
return 1;
}
+#endif
/* MAKESESSIONKEY -- Generate session key with optional start
unsigned char md5key[16], md5key1[16];
char s[1024];
+#define ss sizeof(s)
+
s[0] = 0;
if (seed != NULL) {
bstrncat(s, seed, sizeof(s));
LARGE_INTEGER li;
DWORD length;
FILETIME ft;
- char *p;
- p = s;
- sprintf(s + strlen(s), "%lu", (unsigned long)GetCurrentProcessId());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)GetCurrentProcessId());
(void)getcwd(s + strlen(s), 256);
- sprintf(s + strlen(s), "%lu", (unsigned long)GetTickCount());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)GetTickCount());
QueryPerformanceCounter(&li);
- sprintf(s + strlen(s), "%lu", (unsigned long)li.LowPart);
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)li.LowPart);
GetSystemTimeAsFileTime(&ft);
- sprintf(s + strlen(s), "%lu", (unsigned long)ft.dwLowDateTime);
- sprintf(s + strlen(s), "%lu", (unsigned long)ft.dwHighDateTime);
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)ft.dwLowDateTime);
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)ft.dwHighDateTime);
length = 256;
GetComputerName(s + strlen(s), &length);
length = 256;
GetUserName(s + strlen(s), &length);
}
#else
- sprintf(s + strlen(s), "%lu", (unsigned long)getpid());
- sprintf(s + strlen(s), "%lu", (unsigned long)getppid());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)getpid());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)getppid());
(void)getcwd(s + strlen(s), 256);
- sprintf(s + strlen(s), "%lu", (unsigned long)clock());
- sprintf(s + strlen(s), "%lu", (unsigned long)time(NULL));
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)clock());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)time(NULL));
#if defined(Solaris)
sysinfo(SI_HW_SERIAL,s + strlen(s), 12);
#endif
#if defined(HAVE_GETHOSTID)
- sprintf(s + strlen(s), "%lu", (unsigned long) gethostid());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t) gethostid());
#endif
gethostname(s + strlen(s), 256);
- sprintf(s + strlen(s), "%u", (unsigned)getuid());
- sprintf(s + strlen(s), "%u", (unsigned)getgid());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)getuid());
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)getgid());
#endif
MD5Init(&md5c);
- MD5Update(&md5c, (unsigned char *)s, strlen(s));
+ MD5Update(&md5c, (uint8_t *)s, strlen(s));
MD5Final(md5key, &md5c);
- sprintf(s + strlen(s), "%lu", (unsigned long)((time(NULL) + 65121) ^ 0x375F));
+ bsnprintf(s + strlen(s), ss, "%lu", (uint32_t)((time(NULL) + 65121) ^ 0x375F));
MD5Init(&md5c);
- MD5Update(&md5c, (unsigned char *)s, strlen(s));
+ MD5Update(&md5c, (uint8_t *)s, strlen(s));
MD5Final(md5key1, &md5c);
#define nextrand (md5key[j] ^ md5key1[j])
if (mode) {
}
#undef nextrand
+void encode_session_key(char *encode, char *session, char *key, int maxlen)
+{
+ int i;
+ for (i=0; (i < maxlen-1) && session[i]; i++) {
+ if (session[i] == '-') {
+ encode[i] = '-';
+ } else {
+ encode[i] = ((session[i] - 'A' + key[i]) & 0xF) + 'A';
+ }
+ }
+ encode[i] = 0;
+ Dmsg3(000, "Session=%s key=%s encode=%s\n", session, key, encode);
+}
+
+void decode_session_key(char *decode, char *session, char *key, int maxlen)
+{
+ int i, x;
+
+ for (i=0; (i < maxlen-1) && session[i]; i++) {
+ if (session[i] == '-') {
+ decode[i] = '-';
+ } else {
+ x = (session[i] - 'A' - key[i]) & 0xF;
+ if (x < 0) {
+ x += 16;
+ }
+ decode[i] = x + 'A';
+ }
+ }
+ decode[i] = 0;
+ Dmsg3(000, "Session=%s key=%s decode=%s\n", session, key, decode);
+}
+
/*
* %j = Unique Job id
* %l = job level
* %n = Unadorned Job name
+ * %p = Pool name (Director)
+ * %P = Process PID
+ * %w = Write Store (Director)
+ * %x = Spool Data (Director)
+ * %D = Director name (Director/FileDaemon)
+ * %C = Cloned (Director)
+ * %I = wjcr->JobId (Director)
+ * %f = FileSet (Director)
+ * %h = Client Address (Director)
* %s = Since time
* %t = Job type (Backup, ...)
* %r = Recipients
* %v = Volume name
+ * %b = Job Bytes
+ * %F = Job Files
+ * %E = Job Errors
+ * %R = Job ReadBytes
+ * %S = Previous Job name (FileDaemon) for Incremental/Differential
*
* omsg = edited output message
* imsg = input string containing edit codes (%x)
* to = recepients list
*
*/
-POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to)
+POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to, job_code_callback_t callback)
{
char *p, *q;
const char *str;
- char add[20];
+ char add[50];
char name[MAX_NAME_LENGTH];
int i;
break;
case 'e':
if (jcr) {
- str = job_status_to_str(jcr->JobStatus);
+ str = job_status_to_str(jcr->JobStatus, jcr->getErrors());
} else {
str = _("*none*");
}
break;
+ case 'E': /* Job Errors */
+ str = edit_uint64(jcr->getErrors(), add);
+ break;
case 'i':
if (jcr) {
bsnprintf(add, sizeof(add), "%d", jcr->JobId);
break;
case 'l':
if (jcr) {
- str = job_level_to_str(jcr->JobLevel);
+ str = job_level_to_str(jcr->getJobLevel());
} else {
str = _("*none*");
}
str = _("*none*");
}
break;
+ case 'F': /* Job Files */
+ str = edit_uint64(jcr->JobFiles, add);
+ break;
+ case 'b': /* Job Bytes */
+ str = edit_uint64(jcr->JobBytes, add);
+ break;
case 't':
if (jcr) {
- str = job_type_to_str(jcr->JobType);
+ str = job_type_to_str(jcr->getJobType());
} else {
str = _("*none*");
}
str = _("*none*");
}
break;
- default:
- add[0] = '%';
- add[1] = *p;
- add[2] = 0;
+ case 'P':
+ edit_uint64(getpid(), add);
str = add;
break;
+ case 'R': /* Job ReadBytes */
+ str = edit_uint64(jcr->ReadBytes, add);
+ break;
+ default:
+ str = NULL;
+ if (callback != NULL) {
+ str = callback(jcr, p, add, sizeof(add));
+ }
+
+ if (!str) {
+ add[0] = '%';
+ add[1] = *p;
+ add[2] = 0;
+ str = add;
+ }
+ break;
}
} else {
add[0] = *p;
}
working_directory = wd; /* set global */
}
+
+const char *last_path_separator(const char *str)
+{
+ if (*str != '\0') {
+ for (const char *p = &str[strlen(str) - 1]; p >= str; p--) {
+ if (IsPathSeparator(*p)) {
+ return p;
+ }
+ }
+ }
+ return NULL;
+}
projects / bacula / bacula / blobdiff