/*
* Change to specified directory
*/
TREE_NODE *tree_cwd(char *path, TREE_ROOT *root, TREE_NODE *node)
{
if (path[0] == '.' && path[1] == '\0') {
return node;
}
/*
* Handle relative path
*/
if (path[0] == '.' && path[1] == '.' && (IsPathSeparator(path[2]) || path[2] == '\0')) {
TREE_NODE *parent = node->parent ? node->parent : node;
if (path[2] == 0) {
return parent;
} else {
return tree_cwd(path+3, root, parent);
}
}
if (IsPathSeparator(path[0])) {
Dmsg0(100, "Doing absolute lookup.\n");
return tree_relcwd(path+1, root, (TREE_NODE *)root);
}
Dmsg0(100, "Doing relative lookup.\n");
return tree_relcwd(path, root, node);
}
// Removes any redundant separators that might be in the pathname. // For example, "bar///foo" becomes "bar/foo". Does not eliminate other // redundancies that might be in a pathname involving "." or "..". // TODO([email protected]): handle Windows network shares (e.g. \\server\share). void FilePath::Normalize() { if (pathname_.c_str() == NULL) { pathname_ = ""; return; } const char* src = pathname_.c_str(); char* const dest = new char[pathname_.length() + 1]; char* dest_ptr = dest; memset(dest_ptr, 0, pathname_.length() + 1); while (*src != '\0') { *dest_ptr = *src; if (!IsPathSeparator(*src)) { src++; } else { #if GTEST_HAS_ALT_PATH_SEP_ if (*dest_ptr == kAlternatePathSeparator) { *dest_ptr = kPathSeparator; } #endif while (IsPathSeparator(*src)) src++; } dest_ptr++; } *dest_ptr = '\0'; pathname_ = dest; delete[] dest; }
static void tree_getpath_item(TREE_NODE *node, POOLMEM **path)
{
if (!node) {
return;
}
tree_getpath_item(node->parent, path);
/*
* Fixup for Win32. If we have a Win32 directory and
* there is only a / in the buffer, remove it since
* win32 names don't generally start with /
*/
if (node->type == TN_DIR_NLS && IsPathSeparator((*path[0])) && (*path)[1] == '\0') {
pm_strcpy(path, "");
}
pm_strcat(path, node->fname);
/*
* Add a slash for all directories unless we are at the root,
* also add a slash to a soft linked file if it has children
* i.e. it is linked to a directory.
*/
if ((node->type != TN_FILE && !(IsPathSeparator((*path)[0]) && (*path)[1] == '\0')) ||
(node->soft_link && tree_node_has_child(node))) {
pm_strcat(path, "/");
}
}
/*
* Do in place strip of path
*/
static bool do_strip(int count, char *in)
{
char *out = in;
int stripped;
int numsep = 0;
/* Copy to first path separator -- Win32 might have c: ... */
while (*in && !IsPathSeparator(*in)) {
out++; in++;
}
out++; in++;
numsep++; /* one separator seen */
for (stripped=0; stripped<count && *in; stripped++) {
while (*in && !IsPathSeparator(*in)) {
in++; /* skip chars */
}
if (*in) {
numsep++; /* count separators seen */
in++; /* skip separator */
}
}
/* Copy to end */
while (*in) { /* copy to end */
if (IsPathSeparator(*in)) {
numsep++;
}
*out++ = *in++;
}
*out = 0;
Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
stripped, count, numsep, numsep>count);
return stripped==count && numsep>count;
}
// Returns true if pathname describes an absolute path.
bool FilePath::IsAbsolutePath() const {
const char* const name = pathname_.c_str();
#if GTEST_OS_WINDOWS
return pathname_.length() >= 3 &&
((name[0] >= 'a' && name[0] <= 'z') ||
(name[0] >= 'A' && name[0] <= 'Z')) &&
name[1] == ':' &&
IsPathSeparator(name[2]);
#else
return IsPathSeparator(name[0]);
#endif
}
/*
* Given a full filename, split it into its path
* and filename parts. They are returned in pool memory
* in the mdb structure.
*/
void split_path_and_file(JCR *jcr, B_DB *mdb, const char *fname)
{
const char *p, *f;
/* Find path without the filename.
* I.e. everything after the last / is a "filename".
* OK, maybe it is a directory name, but we treat it like
* a filename. If we don't find a / then the whole name
* must be a path name (e.g. c:).
*/
for (p=f=fname; *p; p++) {
if (IsPathSeparator(*p)) {
f = p; /* set pos of last slash */
}
}
if (IsPathSeparator(*f)) { /* did we find a slash? */
f++; /* yes, point to filename */
} else {
f = p; /* no, whole thing must be path name */
}
/* If filename doesn't exist (i.e. root directory), we
* simply create a blank name consisting of a single
* space. This makes handling zero length filenames
* easier.
*/
mdb->fnl = p - f;
if (mdb->fnl > 0) {
mdb->fname = check_pool_memory_size(mdb->fname, mdb->fnl+1);
memcpy(mdb->fname, f, mdb->fnl); /* copy filename */
mdb->fname[mdb->fnl] = 0;
} else {
mdb->fname[0] = 0;
mdb->fnl = 0;
}
mdb->pnl = f - fname;
if (mdb->pnl > 0) {
mdb->path = check_pool_memory_size(mdb->path, mdb->pnl+1);
memcpy(mdb->path, fname, mdb->pnl);
mdb->path[mdb->pnl] = 0;
} else {
Mmsg1(&mdb->errmsg, _("Path length is zero. File=%s\n"), fname);
Jmsg(jcr, M_ERROR, 0, "%s", mdb->errmsg);
mdb->path[0] = 0;
mdb->pnl = 0;
}
Dmsg2(500, "split path=%s file=%s\n", mdb->path, mdb->fname);
}
char *
getPath(
const char *pszFullPath
)
{
char szDrive[_MAX_DRIVE];
char szDir[_MAX_DIR];
char *szPath;
char *pszSlash;
// Separate the components of the fullpath
_splitpath(pszFullPath, szDrive, szDir, NULL, NULL);
// Allocate just enough memory to hold the drive/path combo then
// Glue just the drive and dir component back together.
szPath = (char *) rallocate(_tcslen(szDrive) + _tcslen(szDir) + 1);
_makepath(szPath, szDrive, szDir, NULL, NULL);
// Eliminate the trailing slash/blackslash to retain compatibility with
// the older version of getPath()
pszSlash = szPath + _tcslen(szPath) - 1;
if (IsPathSeparator(*pszSlash)) {
*pszSlash = '\0';
}
return szPath;
}
/*
* Returns false on error
* true on OK, with full_path set to where config file should be
*/
static bool
find_config_file(const char *config_file, char *full_path, int max_path)
{
int file_length = strlen(config_file) + 1;
/* If a full path specified, use it */
if (first_path_separator(config_file) != NULL) {
if (file_length > max_path) {
return false;
}
bstrncpy(full_path, config_file, file_length);
return true;
}
/* config_file is default file name, now find default dir */
const char *config_dir = get_default_configdir();
int dir_length = strlen(config_dir);
if ((dir_length + 1 + file_length) > max_path) {
return false;
}
memcpy(full_path, config_dir, dir_length + 1);
if (!IsPathSeparator(full_path[dir_length - 1])) {
full_path[dir_length++] = '/';
}
memcpy(&full_path[dir_length], config_file, file_length);
return true;
}
LPSTR
CombinePaths(
IN LPCSTR ParentPath,
IN LPCSTR ChildPath,
OUT LPSTR TargetPath // can be same as ParentPath if want to append
)
{
ULONG ParentLength = strlen( ParentPath );
LPSTR p;
assert( ParentPath );
assert( ChildPath );
if ( ParentPath != TargetPath ) {
memcpy( TargetPath, ParentPath, ParentLength );
}
p = TargetPath + ParentLength;
if (( ParentLength > 0 ) &&
( !IsPathSeparator(*(p - 1)) ) ) {
*p++ = PATH_SEPARATOR_CHAR;
}
strcpy( p, ChildPath );
return TargetPath;
}
static void split_path_and_filename(UAContext *ua, RESTORE_CTX *rx, char *name)
{
char *p, *f;
/* Find path without the filename.
* I.e. everything after the last / is a "filename".
* OK, maybe it is a directory name, but we treat it like
* a filename. If we don't find a / then the whole name
* must be a path name (e.g. c:).
*/
for (p=f=name; *p; p++) {
if (IsPathSeparator(*p)) {
f = p; /* set pos of last slash */
}
}
if (IsPathSeparator(*f)) { /* did we find a slash? */
f++; /* yes, point to filename */
} else { /* no, whole thing must be path name */
f = p;
}
/* If filename doesn't exist (i.e. root directory), we
* simply create a blank name consisting of a single
* space. This makes handling zero length filenames
* easier.
*/
rx->fnl = p - f;
if (rx->fnl > 0) {
rx->fname = check_pool_memory_size(rx->fname, 2*(rx->fnl)+1);
db_escape_string(ua->jcr, ua->db, rx->fname, f, rx->fnl);
} else {
rx->fname[0] = 0;
rx->fnl = 0;
}
rx->pnl = f - name;
if (rx->pnl > 0) {
rx->path = check_pool_memory_size(rx->path, 2*(rx->pnl)+1);
db_escape_string(ua->jcr, ua->db, rx->path, name, rx->pnl);
} else {
rx->path[0] = 0;
rx->pnl = 0;
}
Dmsg2(100, "split path=%s file=%s\n", rx->path, rx->fname);
}
/*
* Open a device.
*/
void DEVICE::open_device(DCR *dcr, int omode)
{
POOL_MEM archive_name(PM_FNAME);
get_autochanger_loaded_slot(dcr);
/*
* Handle opening of File Archive (not a tape)
*/
pm_strcpy(archive_name, dev_name);
/*
* If this is a virtual autochanger (i.e. changer_res != NULL) we simply use
* the device name, assuming it has been appropriately setup by the "autochanger".
*/
if (!device->changer_res || device->changer_command[0] == 0) {
if (VolCatInfo.VolCatName[0] == 0) {
Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
print_name());
clear_opened();
return;
}
if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
pm_strcat(archive_name, "/");
}
pm_strcat(archive_name, getVolCatName());
}
mount(dcr, 1); /* do mount if required */
open_mode = omode;
set_mode(omode);
/*
* If creating file, give 0640 permissions
*/
Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
archive_name.c_str(), oflags);
if ((m_fd = d_open(archive_name.c_str(), oflags, 0640)) < 0) {
berrno be;
dev_errno = errno;
Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
be.bstrerror());
Dmsg1(100, "open failed: %s", errmsg);
}
if (m_fd >= 0) {
dev_errno = 0;
file = 0;
file_addr = 0;
}
Dmsg1(100, "open dev: disk fd=%d opened\n", m_fd);
}
// Returns true if pathname describes a root directory. (Windows has one
// root directory per disk drive.)
bool FilePath::IsRootDirectory() const {
#if GTEST_OS_WINDOWS
// TODO([email protected]): on Windows a network share like
// \\server\share can be a root directory, although it cannot be the
// current directory. Handle this properly.
return pathname_.length() == 3 && IsAbsolutePath();
#else
return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
#endif
}
std::string FileSystemAbstraction::RemoveLocalPathPrefix(const std::string& path)
{
std::string p(path);
if ((p.length() >= 2) && (p[0] == '.') && IsPathSeparator(p[1])) {
p.erase(0, 2);
}
return p;
}
bool ezPathUtils::IsAbsolutePath(const char* szPath)
{
if (ezStringUtils::IsNullOrEmpty (szPath))
return false;
// szPath[0] will not be \0 -> so we can access szPath[1] without problems
#if EZ_ENABLED(EZ_PLATFORM_WINDOWS)
/// if it is an absolute path, character 0 must be ASCII (A - Z)
/// checks for local paths, i.e. 'C:\stuff' and UNC paths, i.e. '\\server\stuff'
/// not sure if we should handle '//' identical to '\\' (currently we do)
return ((szPath[1] == ':') || (IsPathSeparator(szPath[0]) && IsPathSeparator(szPath[1])));
#elif EZ_ENABLED(EZ_PLATFORM_LINUX)
return (szPath[0] == '/');
#elif EZ_ENABLED(EZ_PLATFORM_OSX)
return (szPath[0] == '/');
#else
#error Unknown platform.
#endif
}
/*
* Load all the plugins in the specified directory.
* Or when plugin_names is give it has a list of plugins
* to load from the specified directory.
*/
bool load_plugins(void *binfo,
void *bfuncs,
alist *plugin_list,
const char *plugin_dir,
alist *plugin_names,
const char *type,
bool is_plugin_compatible(Plugin *plugin))
{
struct stat statp;
bool found = false;
POOL_MEM fname(PM_FNAME);
bool need_slash = false;
int len;
Dmsg0(dbglvl, "load_plugins\n");
len = strlen(plugin_dir);
if (len > 0) {
need_slash = !IsPathSeparator(plugin_dir[len - 1]);
}
/*
* See if we are loading certain plugins only or all plugins of a certain type.
*/
if (plugin_names && plugin_names->size()) {
char *name;
POOL_MEM plugin_name(PM_FNAME);
foreach_alist(name, plugin_names) {
/*
* Generate the plugin name e.g. <name>-<daemon>.so
*/
Mmsg(plugin_name, "%s%s", name, type);
/*
* Generate the full pathname to the plugin to load.
*/
Mmsg(fname, "%s%s%s", plugin_dir, (need_slash) ? "/" : "", plugin_name.c_str());
/*
* Make sure the plugin exists and is a regular file.
*/
if (lstat(fname.c_str(), &statp) != 0 || !S_ISREG(statp.st_mode)) {
continue;
}
/*
* Try to load the plugin and resolve the wanted symbols.
*/
if (load_a_plugin(binfo, bfuncs, fname.c_str(), plugin_name.c_str(), type,
plugin_list, is_plugin_compatible)) {
found = true;
}
}
static void strip_double_slashes(char *fname)
{
char *p = fname;
while (p && *p) {
p = strpbrk(p, "/\\");
if (p != NULL) {
if (IsPathSeparator(p[1])) {
strcpy(p, p+1);
}
p++;
}
}
}
/*
* Returns: > 0 index into path where last path char is.
* 0 no path
* -1 filename is zero length
*/
static int separate_path_and_file(JCR *jcr, char *fname, char *ofile)
{
char *f, *p, *q;
int fnl, pnl;
/* Separate pathname and filename */
for (q=p=f=ofile; *p; p++) {
#ifdef HAVE_WIN32
if (IsPathSeparator(*p)) {
f = q;
if (IsPathSeparator(p[1])) {
p++;
}
}
*q++ = *p; /* copy data */
#else
if (IsPathSeparator(*p)) {
f = q; /* possible filename */
}
q++;
#endif
}
if (IsPathSeparator(*f)) {
f++;
}
*q = 0; /* terminate string */
fnl = q - f;
if (fnl == 0) {
/* The filename length must not be zero here because we
* are dealing with a file (i.e. FT_REGE or FT_REG).
*/
Jmsg1(jcr, M_ERROR, 0, _("Zero length filename: %s\n"), fname);
return -1;
}
pnl = f - ofile - 1;
return pnl;
}
std::string FileSystemAbstraction::StripTrailingSlashes(const std::string& path)
{
size_t len = path.length();
while (len > 0) {
if (IsPathSeparator(path.at(len - 1))) {
--len;
} else {
break;
}
}
return path.substr(0, len);
}
const char* ezPathUtils::FindPreviousSeparator(const char* szPathStart, const char* szStartSearchAt)
{
if (ezStringUtils::IsNullOrEmpty(szPathStart))
return nullptr;
while (szStartSearchAt > szPathStart)
{
ezUnicodeUtils::MoveToPriorUtf8(szStartSearchAt);
if (IsPathSeparator(*szStartSearchAt))
return szStartSearchAt;
}
return nullptr;
}
bool FileSystemAbstraction::IsFSRoot(const std::string& p)
{
bool isFsRoot = false;
#ifdef WIN32
// examples: "C:\", "C:/", "C:", "c:", "D:"
isFsRoot = (p.length() >= 2 && p[1] == ':' &&
((p[0] >= 'a' && p[0] <= 'z') || (p[0] >= 'A' && p[0] <= 'Z')) &&
(p.length() == 2 || (p.length() == 3 && IsPathSeparator(p[2]))));
#else
// examples: "/"
isFsRoot = (p.length() == 1 && IsNativePathSeparator(p[0]));
#endif
return isFsRoot;
}
static void add_file_and_part_name(DEVICE *dev, POOL_MEM &archive_name)
{
char partnumber[20];
if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
pm_strcat(archive_name, "/");
}
pm_strcat(archive_name, dev->getVolCatName());
/* if part > 1, append .# to the filename (where # is the part number) */
if (dev->part > 1) {
pm_strcat(archive_name, ".");
bsnprintf(partnumber, sizeof(partnumber), "%d", dev->part);
pm_strcat(archive_name, partnumber);
}
Dmsg2(400, "Exit add_file_part_name: arch=%s, part=%d\n",
archive_name.c_str(), dev->part);
}
HRESULT GetCacheLocationFromReg()
{
HRESULT hr = S_OK;
WCHAR szBuf[MAX_PATH+1];
if (!PAL_FetchConfigurationString(TRUE, REG_VAL_FUSION_CACHE_LOCATION, szBuf, MAX_PATH))
{
hr = E_FAIL;
goto exit;
}
if(!PathCanonicalize(g_szWindowsDir, szBuf))
{
hr = E_FAIL;
goto exit;
}
g_cchWindowsDir = lstrlen(g_szWindowsDir);
if(g_cchWindowsDir && (IsPathSeparator(g_szWindowsDir[g_cchWindowsDir - 1])))
g_szWindowsDir[g_cchWindowsDir - 1] = L'\0'; // remove trailing "\"
// cache location cannot be = MAX_PATH; that won't leave any space for fusion dirs.
if ((g_cchWindowsDir + TEMP_RANDOM_DIR_LENGTH)>= (MAX_PATH/2) )
{
hr = HRESULT_FROM_WIN32(FUSION_E_INVALID_NAME);
goto exit;
}
g_cchWindowsDir = lstrlen(g_szWindowsDir);
if(GetFileAttributes(g_szWindowsDir) != (DWORD) -1)
goto exit;
if(SUCCEEDED(hr = CreateFilePathHierarchy(g_szWindowsDir)))
{
if(!CreateDirectory(g_szWindowsDir, NULL))
hr = FusionpHresultFromLastError();
}
exit:
return hr;
}
ezStringView ezPathUtils::GetFileDirectory(const char* szPath, const char* szPathEnd)
{
// make sure szPathEnd is valid
ezStringUtils::UpdateStringEnd(szPath, szPathEnd);
ezStringView end (szPath, szPathEnd);
end.ResetToBack();
// if it already ends in a path separator, do not return a different directory
if (IsPathSeparator(end.GetCharacter()))
return ezStringView(szPath, szPathEnd);
// find the last separator in the string
const char* szSeparator = FindPreviousSeparator(szPath, szPathEnd);
// no path separator -> root dir -> return the empty path
if (szSeparator == nullptr)
return ezStringView(nullptr);
return ezStringView(szPath, szSeparator + 1);
}
/*
* Remove old .spool files written by me from the working directory.
*/
static void cleanup_old_files()
{
DIR* dp;
struct dirent *entry, *result;
int rc, name_max;
int my_name_len = strlen(my_name);
int len = strlen(me->working_directory);
POOLMEM *cleanup = get_pool_memory(PM_MESSAGE);
POOLMEM *basename = get_pool_memory(PM_MESSAGE);
regex_t preg1;
char prbuf[500];
const int nmatch = 30;
regmatch_t pmatch[nmatch];
berrno be;
/* Look for .spool files but don't allow spaces */
const char *pat1 = "^[^ ]+\\.spool$";
/* Setup working directory prefix */
pm_strcpy(basename, me->working_directory);
if (len > 0 && !IsPathSeparator(me->working_directory[len-1])) {
pm_strcat(basename, "/");
}
/* Compile regex expressions */
rc = regcomp(&preg1, pat1, REG_EXTENDED);
if (rc != 0) {
regerror(rc, &preg1, prbuf, sizeof(prbuf));
Pmsg2(000, _("Could not compile regex pattern \"%s\" ERR=%s\n"),
pat1, prbuf);
goto get_out2;
}
name_max = pathconf(".", _PC_NAME_MAX);
if (name_max < 1024) {
name_max = 1024;
}
if (!(dp = opendir(me->working_directory))) {
berrno be;
Pmsg2(000, "Failed to open working dir %s for cleanup: ERR=%s\n",
me->working_directory, be.bstrerror());
goto get_out1;
}
entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
while (1) {
if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
break;
}
/* Exclude any name with ., .., not my_name or containing a space */
if (strcmp(result->d_name, ".") == 0 || strcmp(result->d_name, "..") == 0 ||
strncmp(result->d_name, my_name, my_name_len) != 0) {
Dmsg1(500, "Skipped: %s\n", result->d_name);
continue;
}
/* Unlink files that match regex */
if (regexec(&preg1, result->d_name, nmatch, pmatch, 0) == 0) {
pm_strcpy(cleanup, basename);
pm_strcat(cleanup, result->d_name);
Dmsg1(500, "Unlink: %s\n", cleanup);
unlink(cleanup);
}
}
free(entry);
closedir(dp);
get_out1:
regfree(&preg1);
get_out2:
free_pool_memory(cleanup);
free_pool_memory(basename);
}
void TestStackFunctions::TestIsPathSeparatorWithAnyOther()
{
assertMessage(!IsPathSeparator(_T('x')), _T("'x' is a NOT path separator, and IsPathSeparator returned true"));
}
void TestStackFunctions::TestIsPathSeparatorWithColon()
{
assertMessage(IsPathSeparator(_T(':')), _T("':' is a path separator, and IsPathSeparator returned false"));
}
void TestStackFunctions::TestIsPathSeparatorWithForwardSlash()
{
assertMessage(IsPathSeparator(_T('/')), _T("'/' is a path separator, and IsPathSeparator returned false"));
}
void TestStackFunctions::TestIsPathSeparatorWithBackSlash()
{
assertMessage(IsPathSeparator('\\'), _T("'\\' is a path separator, and IsPathSeparator returned false"));
}
/*
* The first step in the restore process is for the user to
* select a list of JobIds from which he will subsequently
* select which files are to be restored.
*
* Returns: 2 if filename list made
* 1 if jobid list made
* 0 on error
*/
static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
{
char *p;
char date[MAX_TIME_LENGTH];
bool have_date = false;
/* Include current second if using current time */
utime_t now = time(NULL) + 1;
JobId_t JobId;
JOB_DBR jr = { (JobId_t)-1 };
bool done = false;
int i, j;
const char *list[] = {
_("List last 20 Jobs run"),
_("List Jobs where a given File is saved"),
_("Enter list of comma separated JobIds to select"),
_("Enter SQL list command"),
_("Select the most recent backup for a client"),
_("Select backup for a client before a specified time"),
_("Enter a list of files to restore"),
_("Enter a list of files to restore before a specified time"),
_("Find the JobIds of the most recent backup for a client"),
_("Find the JobIds for a backup for a client before a specified time"),
_("Enter a list of directories to restore for found JobIds"),
_("Select full restore to a specified Job date"),
_("Cancel"),
NULL
};
const char *kw[] = {
/*
* These keywords are handled in a for loop
*/
"jobid", /* 0 */
"current", /* 1 */
"before", /* 2 */
"file", /* 3 */
"directory", /* 4 */
"select", /* 5 */
"pool", /* 6 */
"all", /* 7 */
/*
* The keyword below are handled by individual arg lookups
*/
"client", /* 8 */
"storage", /* 9 */
"fileset", /* 10 */
"where", /* 11 */
"yes", /* 12 */
"bootstrap", /* 13 */
"done", /* 14 */
"strip_prefix", /* 15 */
"add_prefix", /* 16 */
"add_suffix", /* 17 */
"regexwhere", /* 18 */
"restoreclient", /* 19 */
"copies", /* 20 */
"comment", /* 21 */
"restorejob", /* 22 */
"replace", /* 23 */
"pluginoptions", /* 24 */
NULL
};
rx->JobIds[0] = 0;
for (i = 1; i<ua->argc; i++) { /* loop through arguments */
bool found_kw = false;
for (j = 0; kw[j]; j++) { /* loop through keywords */
if (bstrcasecmp(kw[j], ua->argk[i])) {
found_kw = true;
break;
}
}
if (!found_kw) {
ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
return 0;
}
/* Found keyword in kw[] list, process it */
switch (j) {
case 0: /* jobid */
if (!has_value(ua, i)) {
return 0;
}
if (*rx->JobIds != 0) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->argv[i]);
done = true;
break;
case 1: /* current */
/*
* Note, we add one second here just to include any job
* that may have finished within the current second,
* which happens a lot in scripting small jobs.
*/
bstrutime(date, sizeof(date), now);
have_date = true;
break;
case 2: /* before */
if (have_date || !has_value(ua, i)) {
return 0;
}
if (str_to_utime(ua->argv[i]) == 0) {
ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
return 0;
}
bstrncpy(date, ua->argv[i], sizeof(date));
have_date = true;
break;
case 3: /* file */
case 4: /* dir */
if (!has_value(ua, i)) {
return 0;
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
pm_strcpy(ua->cmd, ua->argv[i]);
insert_one_file_or_dir(ua, rx, date, j==4);
return 2;
case 5: /* select */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = true;
break;
case 6: /* pool specified */
if (!has_value(ua, i)) {
return 0;
}
rx->pool = (POOLRES *)GetResWithName(R_POOL, ua->argv[i]);
if (!rx->pool) {
ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
return 0;
}
if (!acl_access_ok(ua, Pool_ACL, ua->argv[i], true)) {
rx->pool = NULL;
ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
return 0;
}
break;
case 7: /* all specified */
rx->all = true;
break;
default:
/*
* All keywords 7 or greater are ignored or handled by a select prompt
*/
break;
}
}
if (!done) {
ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
"to be restored. You will be presented several methods\n"
"of specifying the JobIds. Then you will be allowed to\n"
"select which files from those JobIds are to be restored.\n\n"));
}
/* If choice not already made above, prompt */
for ( ; !done; ) {
char *fname;
int len;
bool gui_save;
db_list_ctx jobids;
start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
for (int i=0; list[i]; i++) {
add_prompt(ua, list[i]);
}
done = true;
switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
case -1: /* error or cancel */
return 0;
case 0: /* list last 20 Jobs run */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 1: /* list where a file is saved */
if (!get_client_name(ua, rx)) {
return 0;
}
if (!get_cmd(ua, _("Enter Filename (no path):"))) {
return 0;
}
len = strlen(ua->cmd);
fname = (char *)malloc(len * 2 + 1);
db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
Mmsg(rx->query, uar_file[db_get_type_index(ua->db)], rx->ClientName, fname);
free(fname);
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, rx->query, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 2: /* enter a list of JobIds */
if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
return 0;
}
pm_strcpy(rx->JobIds, ua->cmd);
break;
case 3: /* Enter an SQL list command */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
if (!get_cmd(ua, _("Enter SQL list command: "))) {
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, ua->cmd, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 4: /* Select the most recent backups */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 5: /* select backup at specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 6: /* Enter files */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 7: /* enter files backed up before specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 8: /* Find JobIds for current backup */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 9: /* Find JobIds for give date */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 10: /* Enter directories */
if (*rx->JobIds != 0) {
ua->send_msg(_("You have already selected the following JobIds: %s\n"),
rx->JobIds);
} else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
if (*rx->JobIds != 0 && *ua->cmd) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->cmd);
}
if (*rx->JobIds == 0 || *rx->JobIds == '.') {
*rx->JobIds = 0;
return 0; /* nothing entered, return */
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter full directory names or start the name\n"
"with a < to indicate it is a filename containing a list\n"
"of directories and terminate them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter directory name: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
/* Add trailing slash to end of directory names */
if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
strcat(ua->cmd, "/");
}
insert_one_file_or_dir(ua, rx, date, true);
}
return 2;
case 11: /* Choose a jobid and select jobs */
if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
!is_an_integer(ua->cmd))
{
return 0;
}
memset(&jr, 0, sizeof(jr));
jr.JobId = str_to_int64(ua->cmd);
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
ua->cmd, db_strerror(ua->db));
return 0;
}
ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
jr.cStartTime);
jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
return 0;
}
pm_strcpy(rx->JobIds, jobids.list);
Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
break;
case 12: /* Cancel or quit */
return 0;
}
}
memset(&jr, 0, sizeof(jr));
POOLMEM *JobIds = get_pool_memory(PM_FNAME);
*JobIds = 0;
rx->TotalFiles = 0;
/*
* Find total number of files to be restored, and filter the JobId
* list to contain only ones permitted by the ACL conditions.
*/
for (p=rx->JobIds; ; ) {
char ed1[50];
int status = get_next_jobid_from_list(&p, &JobId);
if (status < 0) {
ua->error_msg(_("Invalid JobId in list.\n"));
free_pool_memory(JobIds);
return 0;
}
if (status == 0) {
break;
}
if (jr.JobId == JobId) {
continue; /* duplicate of last JobId */
}
memset(&jr, 0, sizeof(jr));
jr.JobId = JobId;
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
edit_int64(JobId, ed1), db_strerror(ua->db));
free_pool_memory(JobIds);
return 0;
}
if (!acl_access_ok(ua, Job_ACL, jr.Name, true)) {
ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
edit_int64(JobId, ed1), jr.Name);
continue;
}
if (*JobIds != 0) {
pm_strcat(JobIds, ",");
}
pm_strcat(JobIds, edit_int64(JobId, ed1));
rx->TotalFiles += jr.JobFiles;
}
free_pool_memory(rx->JobIds);
rx->JobIds = JobIds; /* Set ACL filtered list */
if (*rx->JobIds == 0) {
ua->warning_msg(_("No Jobs selected.\n"));
return 0;
}
if (strchr(rx->JobIds,',')) {
ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
} else {
ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
}
return true;
}
void conv_unix_to_win32_path(const char *name, char *win32_name, DWORD dwSize)
{
char *tname=win32_name;
const char *fname=name;
if(IsPathSeparator(name[0])
&& IsPathSeparator(name[1])
&& name[2]=='.'
&& IsPathSeparator(name[3]))
{
*win32_name++='\\';
*win32_name++='\\';
*win32_name++='.';
*win32_name++='\\';
name+=4;
}
else if(g_platform_id!=VER_PLATFORM_WIN32_WINDOWS
&& !g_pVSSPathConvert)
{
// Allow path to be 32767 bytes.
*win32_name++='\\';
*win32_name++='\\';
*win32_name++='?';
*win32_name++='\\';
}
while(*name)
{
// Check for Unix separator and convert to Win32.
if(name[0]=='/' && name[1]=='/')
name++;
if(*name=='/')
*win32_name++='\\';
else if(*name=='\\'&& name[1]=='\\')
{
*win32_name++='\\';
name++;
}
else
*win32_name++=*name;
name++;
}
// Strip any trailing slash, if we stored something.
// But leave "c:\" with backslash (root directory case).
if(*fname && win32_name[-1]=='\\' && strlen(fname)!=3)
win32_name[-1]=0;
else
*win32_name=0;
/* Here we convert to VSS specific file name which
can get longer because VSS will make something like
\\\\?\\GLOBALROOT\\Device\\HarddiskVolumeShadowCopy1\\burp\\x.exe
from c:\burp\x.exe
*/
if(g_pVSSPathConvert)
{
char *pszBuf=sm_get_pool_memory (PM_FNAME);
pszBuf=sm_check_pool_memory_size(pszBuf, dwSize);
snprintf(pszBuf, strlen(tname)+1, "%s", tname);
g_pVSSPathConvert(pszBuf, tname, dwSize);
sm_free_pool_memory(pszBuf);
}
}
