def get_string_from_file(filename):
if not filename: return None
rp = rpath.RPath(Globals.local_connection, filename)
try: return rp.get_data()
except OSError, e:
Log.FatalError("Error '%s' reading mapping file '%s'" %
(str(e), filename))
def vet_filename(request, arglist):
"""Check to see if file operation is within the restrict_path"""
i = file_requests[request.function_string]
if len(arglist) <= i: raise_violation(request, arglist)
filename = arglist[i]
if type(filename) is not types.StringType:
raise_violation(request, arglist)
vet_rpath(rpath.RPath(Globals.local_connection, filename))
def restore_set_root(rpin):
"""Set data dir, restore_root and index, or return None if fail
The idea here is to keep backing up on the path until we find
a directory that contains "rdiff-backup-data". That is the
mirror root. If the path from there starts
"rdiff-backup-data/increments*", then the index is the
remainder minus that. Otherwise the index is just the path
minus the root.
All this could fail if the increment file is pointed to in a
funny way, using symlinks or somesuch.
"""
global restore_root, restore_index, restore_root_set
if rpin.isincfile(): relpath = rpin.getincbase().path
else: relpath = rpin.path
if rpin.conn is not Globals.local_connection:
# For security checking consistency, don't get absolute path
pathcomps = relpath.split('/')
else:
pathcomps = os.path.join(os.getcwd(), relpath).split("/")
if not pathcomps[0]: min_len_pathcomps = 2 # treat abs paths differently
else: min_len_pathcomps = 1
i = len(pathcomps)
while i >= min_len_pathcomps:
parent_dir = rpath.RPath(rpin.conn, "/".join(pathcomps[:i]))
if (parent_dir.isdir() and parent_dir.readable()
and "rdiff-backup-data" in parent_dir.listdir()):
break
if parent_dir.path == rpin.conn.Globals.get('restrict_path'):
return None
i = i - 1
else:
return None
restore_root = parent_dir
Log("Using mirror root directory %s" % restore_root.path, 6)
if restore_root.conn is Globals.local_connection:
Security.reset_restrict_path(restore_root)
SetConnections.UpdateGlobal('rbdir',
restore_root.append_path("rdiff-backup-data"))
if not Globals.rbdir.isdir():
Log.FatalError("Unable to read rdiff-backup-data directory %s" %
Globals.rbdir.path)
from_datadir = tuple(pathcomps[i:])
if not from_datadir or from_datadir[0] != "rdiff-backup-data":
restore_index = from_datadir # in mirror, not increments
else:
assert (from_datadir[1] == "increments" or
(len(from_datadir) == 2
and from_datadir[1].startswith('increments'))), from_datadir
restore_index = from_datadir[2:]
restore_root_set = 1
return 1
def isincfile(self):
"""Return true if path indicates increment, sets various variables"""
if not self.index: # consider the last component as quoted
dirname, basename = self.dirsplit()
temp_rp = rpath.RPath(self.conn, dirname, (unquote(basename), ))
result = temp_rp.isincfile()
if result:
self.inc_basestr = unquote(temp_rp.inc_basestr)
self.inc_timestr = unquote(temp_rp.inc_timestr)
else:
result = rpath.RPath.isincfile(self)
if result: self.inc_basestr = unquote(self.inc_basestr)
return result
def next(self): """Return next object, or StopIteration""" while not self.stored_rorps: try: next_rorp = self.rorp_iter.next() except StopIteration: if self.itr_finished: raise else: self.ITR.Finish() self.itr_finished = 1 else: next_rp = rpath.RPath(self.base_rp.conn, self.base_rp.base, next_rorp.index, next_rorp.data) self.ITR(next_rorp.index, next_rp, next_rorp) return self.stored_rorps.pop(0)
def getrpiter(rorp_iter):
"""Return rp iter by adding indicies of rorp_iter to self.rpath"""
for rorp in rorp_iter:
yield rpath.RPath(self.rpath.conn, self.rpath.base, rorp.index,
rorp.data)
def normalize_path(path): """Used below to normalize the security paths before setting""" return rpath.RPath(Globals.local_connection, path).normalize().path
def cmdpair2rp(cmd_pair):
"""Return normalized RPath from cmd_pair (remote_cmd, filename)"""
cmd, filename = cmd_pair
if cmd: conn = init_connection(cmd)
else: conn = Globals.local_connection
return rpath.RPath(conn, filename).normalize()
def get_quoted_sep_base(filename):
"""Get QuotedRPath from filename assuming last bit is quoted"""
return get_quotedrpath(rpath.RPath(Globals.local_connection, filename), 1)
def set_security_level(action, cmdpairs):
"""If running client, set security level and restrict_path
To find these settings, we must look at the action to see what is
supposed to happen, and then look at the cmdpairs to see what end
the client is on.
"""
def islocal(cmdpair):
return not cmdpair[0]
def bothlocal(cp1, cp2):
return islocal(cp1) and islocal(cp2)
def bothremote(cp1, cp2):
return not islocal(cp1) and not islocal(cp2)
def getpath(cmdpair):
return cmdpair[1]
if Globals.server: return
cp1 = cmdpairs[0]
if len(cmdpairs) > 1: cp2 = cmdpairs[1]
else: cp2 = cp1
if action == "backup" or action == "check-destination-dir":
if bothlocal(cp1, cp2) or bothremote(cp1, cp2):
sec_level = "minimal"
rdir = tempfile.gettempdir()
elif islocal(cp1):
sec_level = "read-only"
rdir = getpath(cp1)
else:
assert islocal(cp2)
sec_level = "update-only"
rdir = getpath(cp2)
elif action == "restore" or action == "restore-as-of":
if len(cmdpairs) == 1 or bothlocal(cp1, cp2) or bothremote(cp1, cp2):
sec_level = "minimal"
rdir = tempfile.gettempdir()
elif islocal(cp1):
sec_level = "read-only"
Main.restore_set_root(
rpath.RPath(Globals.local_connection, getpath(cp1)))
if Main.restore_root: rdir = Main.restore_root.path
else: log.Log.FatalError("Invalid restore directory")
else:
assert islocal(cp2)
sec_level = "all"
rdir = getpath(cp2)
elif action == "mirror":
if bothlocal(cp1, cp2) or bothremote(cp1, cp2):
sec_level = "minimal"
rdir = tempfile.gettempdir()
elif islocal(cp1):
sec_level = "read-only"
rdir = getpath(cp1)
else:
assert islocal(cp2)
sec_level = "all"
rdir = getpath(cp2)
elif action in [
"test-server", "list-increments", 'list-increment-sizes',
"list-at-time", "list-changed-since", "calculate-average",
"remove-older-than", "compare", "compare-hash", "compare-full",
"verify"
]:
sec_level = "minimal"
rdir = tempfile.gettempdir()
else:
assert 0, "Unknown action %s" % action
Globals.security_level = sec_level
Globals.restrict_path = rpath.RPath(Globals.local_connection,
rdir).normalize().path
