def setPassword(crypt, password):
try:
(db, _, _) = getDB(None, None)
crypt.genKeys()
(f, c) = crypt.getKeys()
(salt, vkey) = srp.create_salted_verification_key(args.client, password)
if args.keys:
db.beginTransaction()
db.setSrpValues(salt, vkey)
Util.saveKeys(args.keys, db.getConfigValue('ClientID'), f, c)
db.commit()
else:
db.setKeys(salt, vkey, f, c)
return 0
except TardisDB.NotAuthenticated:
logger.error('Client %s already has a password', args.client)
if args.exceptions:
logger.exception(e)
return 1
except TardisDB.AuthenticationFailed as e:
logger.error("Authentication failed. Bad password")
if args.exceptions:
logger.exception(e)
return 1
except Exception as e:
logger.error(str(e))
if args.exceptions:
logger.exception(e)
return 1
def main():
global logger
progressbar.streams.wrap_stderr()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('')
args = processArgs()
password = Util.getPassword(args.password,
args.passwordfile,
args.passwordprog,
allowNone=False)
(db, cacheDir,
crypto) = Util.setupDataConnection(args.database, args.client, password,
args.keys, args.dbname, args.dbdir)
if args.input:
files = json.load(open(args.input, "r"))
for x in files:
try:
processFile(args.output, crypto, files[x], args.compress,
args.signature)
except Exception as e:
print(f"----> {str(e)} Processing {files[x]}")
traceback.print_exc()
for name in args.names:
try:
processFile(args.output, crypto, name, args.signature)
except Exception as e:
print(f"----> {str(e)} Processing {name}")
traceback.print_exc()
def moveKeys(db, crypt):
try:
if args.keys is None:
logger.error("Must specify key file for key manipulation")
return 1
clientId = db.getConfigValue("ClientID")
token = crypt.createToken()
(db, _) = getDB(crypt)
if args.extract:
(f, c) = db.getKeys()
if not (f and c):
raise Exception("Unable to retrieve keys from server. Aborting.")
Util.saveKeys(args.keys, clientId, f, c)
if args.deleteKeys:
db.setKeys(token, None, None)
elif args.insert:
(f, c) = Util.loadKeys(args.keys, clientId)
logger.info("Keys: F: %s C: %s", f, c)
if not (f and c):
raise Exception("Unable to retrieve keys from key database. Aborting.")
db.setKeys(token, f, c)
if args.deleteKeys:
Util.saveKeys(args.keys, clientId, None, None)
return 0
except Exception as e:
logger.error(e)
logger.exception(e)
return 1
def generateMetadata(db, cacheDir):
conn = db.conn
r = conn.execute("SELECT COUNT(*) FROM CheckSums WHERE IsFile = 1")
n = r.fetchone()[0]
c = conn.cursor()
r = c.execute(
"SELECT Checksum, Size, Compressed, Encrypted, DiskSize, Basis FROM Checksums WHERE IsFile = 1 ORDER BY CheckSum"
)
metas = 0
logger.info("Generating metadata/recovery info for %d files", n)
with progressbar.ProgressBar(max_value=int(n)) as bar:
batch = r.fetchmany(4096)
while batch:
for row in batch:
# recordMetaData(cache, checksum, size, compressed, encrypted, disksize, basis=None, logger=None):
Util.recordMetaData(cacheDir,
row[0],
row[1],
row[2],
row[3],
row[4],
basis=row[5],
logger=logger)
metas += 1
bar.update(metas)
batch = r.fetchmany(4096)
def main():
global logger
progressbar.streams.wrap_stderr()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('')
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog)
crypto = TardisCrypto.TardisCrypto(password, args.client)
path = os.path.join(args.database, args.client, args.dbname)
db = TardisDB.TardisDB(path, backup=False)
Util.authenticate(db, args.client, password)
(f, c) = db.getKeys()
crypto.setKeys(f, c)
cacheDir = CacheDir.CacheDir(os.path.join(args.database, args.client))
if args.names or args.all:
encryptFilenames(db, crypto)
if args.dirs or args.all:
generateDirHashes(db, crypto, cacheDir)
if args.sigs or args.all:
generateSignatures(db, crypto, cacheDir)
if args.files or args.all:
encryptFiles(db, crypto, cacheDir)
if args.meta or args.all:
generateMetadata(db, cacheDir)
def setPassword(password):
try:
(db, _, _) = getDB(None)
crypt = TardisCrypto.getCrypto(TardisCrypto.defaultCryptoScheme,
password)
crypt.genKeys()
(f, c) = crypt.getKeys()
(salt,
vkey) = srp.create_salted_verification_key(args.client, password)
if args.keys:
db.beginTransaction()
db.setSrpValues(salt, vkey)
db.setConfigValue('CryptoScheme', crypt.getCryptoScheme())
Util.saveKeys(args.keys, db.getConfigValue('ClientID'), f, c)
else:
db.setKeys(salt, vkey, f, c)
db.setConfigValue('CryptoScheme', crypt.getCryptoScheme())
return 0
except TardisDB.NotAuthenticated:
logger.error('Client %s already has a password', args.client)
if args.exceptions:
logger.exception(e)
return 1
except TardisDB.AuthenticationFailed as e:
logger.error("Authentication failed. Bad password")
if args.exceptions:
logger.exception(e)
return 1
except Exception as e:
logger.error(str(e))
if args.exceptions:
logger.exception(e)
return 1
def main():
global logger
args = processArgs()
kwargs = processMountOpts(args.mountopts)
logger = Util.setupLogging(args.verbose)
try:
argsDict = vars(args)
def getarg(name):
""" Extract a value from either the kwargs, or the regular args """
return kwargs.get(name) or argsDict.get(name)
# Extract the password file and program, if they exist. Names differ, so getarg doesn't work.
pwfile = kwargs.get('pwfile') or argsDict.get('passwordfile')
pwprog = kwargs.get('pwprog') or argsDict.get('passwordprog')
password = Util.getPassword(getarg('password'), pwfile, pwprog, prompt="Password for %s: " % (getarg('client')))
args.password = None
(tardis, cache, crypt) = Util.setupDataConnection(getarg('database'), getarg('client'), password, getarg('keys'), getarg('dbname'), getarg('dbdir'))
except TardisDB.AuthenticationException as e:
logger.error("Authentication failed. Bad password")
#if args.exceptions:
#logger.exception(e)
sys.exit(1)
except Exception as e:
logger.error("DB Connection failed: %s", e)
sys.exit(1)
delTardisKeys(kwargs)
fs = TardisFS(tardis, cache, crypt, args)
FUSE(fs, args.mountpoint[0], debug=args.debug, nothreads=True, foreground=args.foreground, **kwargs)
def processArgs():
parser = argparse.ArgumentParser(description='Encrypt the database',
add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument('--shell',
dest='shell',
default=getShell(),
help='Shell to use. Default: %(default)s')
parser.add_argument('--verbose',
'-v',
action='count',
default=0,
dest='verbose',
help='Increase the verbosity')
parser.add_argument('--help', '-h', action='help')
Util.addGenCompletions(parser)
args = parser.parse_args(remaining)
return args
def getDB(crypt, password, new=False, allowRemote=True, allowUpgrade=False):
loc = urllib.parse.urlparse(args.database)
# This is basically the same code as in Util.setupDataConnection(). Should consider moving to it.
if (loc.scheme == 'http') or (loc.scheme == 'https'):
if not allowRemote:
raise Exception("This command cannot be executed remotely. You must execute it on the server directly.")
# If no port specified, insert the port
if loc.port is None:
netloc = loc.netloc + ":" + Defaults.getDefault('TARDIS_REMOTE_PORT')
dbLoc = urllib.parse.urlunparse((loc.scheme, netloc, loc.path, loc.params, loc.query, loc.fragment))
else:
dbLoc = args.database
tardisdb = RemoteDB.RemoteDB(dbLoc, args.client)
cache = tardisdb
else:
basedir = os.path.join(args.database, args.client)
if not args.dbdir:
dbdir = os.path.join(args.database, args.client)
else:
dbdir = os.path.join(args.dbdir, args.client)
dbfile = os.path.join(dbdir, args.dbname)
if new and os.path.exists(dbfile):
raise Exception("Database for client %s already exists." % (args.client))
cache = CacheDir.CacheDir(basedir, 2, 2, create=new)
schema = args.schema if new else None
tardisdb = TardisDB.TardisDB(dbfile, backup=False, initialize=schema, allow_upgrade=allowUpgrade)
if tardisdb.needsAuthentication():
if password is None:
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog, prompt="Password for %s: " % (args.client), allowNone=False, confirm=False)
crypt = TardisCrypto.TardisCrypto(password, args.client)
Util.authenticate(tardisdb, args.client, password)
return (tardisdb, cache, crypt)
def main():
global logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('')
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog)
(_, _, crypto) = Util.setupDataConnection(args.database, args.client, password, args.keys, args.dbname, args.dbdir)
data = args.names
if not data:
tty = os.isatty(0)
if not tty:
data = list(map(str.strip, sys.stdin.readlines()))
else:
data = reader(args.quiet)
for i in data:
if i:
if not args.quiet:
print(i, " \t => \t", end=' ')
try:
if (args.encrypt):
print(crypto.encryptPath(i))
else:
print(crypto.decryptPath(i))
except Exception as e:
print("Caught exception: " + str(e))
def moveKeys(db, crypt):
try:
if args.keys is None:
logger.error("Must specify key file for key manipulation")
return 1
clientId = db.getConfigValue('ClientID')
salt, vkey = db.getSrpValues()
#(db, _) = getDB(crypt)
if args.extract:
(f, c) = db.getKeys()
if not (f and c):
raise Exception("Unable to retrieve keys from server. Aborting.")
Util.saveKeys(args.keys, clientId, f, c)
if args.deleteKeys:
db.setKeys(salt, vkey, None, None)
elif args.insert:
(f, c) = Util.loadKeys(args.keys, clientId)
logger.info("Keys: F: %s C: %s", f, c)
if not (f and c):
raise Exception("Unable to retrieve keys from key database. Aborting.")
db.setKeys(salt, vkey, f, c)
if args.deleteKeys:
Util.saveKeys(args.keys, clientId, None, None)
return 0
except TardisDB.AuthenticationException as e:
logger.error("Authentication failed. Bad password")
return 1
except Exception as e:
logger.error(e)
if args.exceptions:
logger.exception(e)
return 1
def main():
global logger
progressbar.streams.wrap_stderr()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('')
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog, allowNone=False)
crypto = TardisCrypto.TardisCrypto(password, args.client)
path = os.path.join(args.database, args.client, args.dbname)
db = TardisDB.TardisDB(path, backup=False)
Util.authenticate(db, args.client, password)
(f, c) = db.getKeys()
crypto.setKeys(f, c)
cacheDir = CacheDir.CacheDir(os.path.join(args.database, args.client))
if args.names or args.all:
encryptFilenames(db, crypto)
if args.dirs or args.all:
generateDirHashes(db, crypto, cacheDir)
if args.sigs or args.all:
generateSignatures(db, crypto, cacheDir)
if args.files or args.all:
encryptFiles(db, crypto, cacheDir)
if args.meta or args.all:
generateMetadata(db, cacheDir)
def _bsetInfo(db, info):
print "Backupset : %s (%d)" % ((info['name']), info['backupset'])
print "Completed : %s" % ('True' if info['completed'] else 'False')
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(info['starttime'])))
print "StartTime : %s" % (t)
if info['endtime'] is not None:
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(info['endtime'])))
duration = str(datetime.timedelta(seconds = (int(float(info['endtime']) - float(info['starttime'])))))
print "EndTime : %s" % (t)
print "Duration : %s" % (duration)
print "SW Versions : C:%s S:%s" % (info['clientversion'], info['serverversion'])
print "Client IP : %s" % (info['clientip'])
details = db.getBackupSetDetails(info['backupset'])
(files, dirs, size, newInfo, endInfo) = details
print "Files : %d" % (files)
print "Directories : %d" % (dirs)
print "Total Size : %s" % (Util.fmtSize(size))
print "New Files : %d" % (newInfo[0])
print "New File Size : %s" % (Util.fmtSize(newInfo[1]))
print "New File Space : %s" % (Util.fmtSize(newInfo[2]))
print "Purgeable Files : %d" % (endInfo[0])
print "Purgeable Size : %s" % (Util.fmtSize(endInfo[1]))
print "Purgeable Space : %s" % (Util.fmtSize(endInfo[2]))
def getDB(crypt, password, new=False, allowRemote=True, allowUpgrade=False):
loc = urlparse.urlparse(args.database)
# This is basically the same code as in Util.setupDataConnection(). Should consider moving to it.
if (loc.scheme == 'http') or (loc.scheme == 'https'):
if not allowRemote:
raise Exception("This command cannot be executed remotely. You must execute it on the server directly.")
# If no port specified, insert the port
if loc.port is None:
netloc = loc.netloc + ":" + Defaults.getDefault('TARDIS_REMOTE_PORT')
dbLoc = urlparse.urlunparse((loc.scheme, netloc, loc.path, loc.params, loc.query, loc.fragment))
else:
dbLoc = args.database
tardisdb = RemoteDB.RemoteDB(dbLoc, args.client)
cache = tardisdb
else:
basedir = os.path.join(args.database, args.client)
if not args.dbdir:
dbdir = os.path.join(args.database, args.client)
else:
dbdir = os.path.join(args.dbdir, args.client)
dbfile = os.path.join(dbdir, args.dbname)
if new and os.path.exists(dbfile):
raise Exception("Database for client %s already exists." % (args.client))
cache = CacheDir.CacheDir(basedir, 2, 2, create=new)
schema = args.schema if new else None
tardisdb = TardisDB.TardisDB(dbfile, backup=False, initialize=schema, allow_upgrade=allowUpgrade)
if tardisdb.needsAuthentication():
if password is None:
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog, prompt="Password for %s: " % (args.client), allowNone=False, confirm=False)
Util.authenticate(tardisdb, args.client, password)
return (tardisdb, cache)
def setPassword(crypt, password):
try:
(db, _) = getDB(None, None)
crypt.genKeys()
(f, c) = crypt.getKeys()
(salt, vkey) = srp.create_salted_verification_key(args.client, password)
if args.keys:
db.beginTransaction()
db.setSrpValues(salt, vkey)
Util.saveKeys(args.keys, db.getConfigValue('ClientID'), f, c)
db.commit()
else:
db.setKeys(salt, vkey, f, c)
return 0
except TardisDB.NotAuthenticated:
logger.error('Client %s already has a password', args.client)
exceptionLogger.log(e)
return 1
except TardisDB.AuthenticationFailed as e:
logger.error("Authentication failed. Bad password")
exceptionLogger.log(e)
return 1
except Exception as e:
logger.error(str(e))
exceptionLogger.log(e)
return 1
def _bsetInfo(db, info):
print("Backupset : %s (%d)" % ((info['name']), info['backupset']))
print("Completed : %s" % ('True' if info['completed'] else 'False'))
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(info['starttime'])))
print("StartTime : %s" % (t))
if info['endtime'] is not None:
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(info['endtime'])))
duration = str(datetime.timedelta(seconds = (int(float(info['endtime']) - float(info['starttime'])))))
print("EndTime : %s" % (t))
print("Duration : %s" % (duration))
print("SW Versions : C:%s S:%s" % (info['clientversion'], info['serverversion']))
print("Client IP : %s" % (info['clientip']))
details = db.getBackupSetDetails(info['backupset'])
(files, dirs, size, newInfo, endInfo) = details
print("Files : %d" % (files))
print("Directories : %d" % (dirs))
print("Total Size : %s" % (Util.fmtSize(size)))
print("New Files : %d" % (newInfo[0]))
print("New File Size : %s" % (Util.fmtSize(newInfo[1])))
print("New File Space : %s" % (Util.fmtSize(newInfo[2])))
print("Purgeable Files : %d" % (endInfo[0]))
print("Purgeable Size : %s" % (Util.fmtSize(endInfo[1])))
print("Purgeable Space : %s" % (Util.fmtSize(endInfo[2])))
def main():
global logger
args = processArgs()
kwargs = processMountOpts(args.mountopts)
logger = Util.setupLogging(args.verbose)
try:
argsDict = vars(args)
def getarg(name):
""" Extract a value from either the kwargs, or the regular args """
return kwargs.get(name) or argsDict.get(name)
# Extract the password file and program, if they exist. Names differ, so getarg doesn't work.
pwfile = kwargs.get('pwfile') or argsDict.get('passwordfile')
pwprog = kwargs.get('pwprog') or argsDict.get('passwordprog')
password = Util.getPassword(getarg('password'), pwfile, pwprog, prompt="Password for %s: " % (getarg('client')))
args.password = None
(tardis, cache, crypt) = Util.setupDataConnection(getarg('database'), getarg('client'), password, getarg('keys'), getarg('dbname'), getarg('dbdir'))
except TardisDB.AuthenticationException as e:
logger.error("Authentication failed. Bad password")
#if args.exceptions:
#logger.exception(e)
sys.exit(1)
except Exception as e:
logger.error("DB Connection failed: %s", e)
sys.exit(1)
delTardisKeys(kwargs)
fs = TardisFS(tardis, cache, crypt, args)
FUSE(fs, args.mountpoint[0], debug=args.debug, nothreads=True, foreground=args.foreground, **kwargs)
def _bsetInfo(db, info):
print "Backupset : %s (%d)" % ((info["name"]), info["backupset"])
print "Completed : %s" % ("True" if info["completed"] else "False")
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(info["starttime"])))
print "StartTime : %s" % (t)
if info["endtime"] is not None:
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(info["endtime"])))
duration = str(datetime.timedelta(seconds=(int(float(info["endtime"]) - float(info["starttime"])))))
print "EndTime : %s" % (t)
print "Duration : %s" % (duration)
print "SW Versions : C:%s S:%s" % (info["clientversion"], info["serverversion"])
print "Client IP : %s" % (info["clientip"])
details = db.getBackupSetDetails(info["backupset"])
(files, dirs, size, newInfo, endInfo) = details
print "Files : %d" % (files)
print "Directories : %d" % (dirs)
print "Total Size : %s" % (Util.fmtSize(size))
print "New Files : %d" % (newInfo[0])
print "New File Size : %s" % (Util.fmtSize(newInfo[1]))
print "New File Space : %s" % (Util.fmtSize(newInfo[2]))
print "Purgeable Files : %d" % (endInfo[0])
print "Purgeable Size : %s" % (Util.fmtSize(endInfo[1]))
print "Purgeable Space : %s" % (Util.fmtSize(endInfo[2]))
def changePassword(crypt, crypt2):
try:
(db, _) = getDB(crypt)
# Load the keys, and insert them into the crypt object, to decyrpt them
if args.keys:
(f, c) = Util.loadKeys(args.keys, db.getConfigValue("ClientID"))
else:
(f, c) = db.getKeys()
crypt.setKeys(f, c)
# Grab the keys from one crypt object.
# Need to do this because getKeys/setKeys assumes they're encrypted, and we need the raw
# versions
crypt2._filenameKey = crypt._filenameKey
crypt2._contentKey = crypt._contentKey
# Now get the encrypted versions
(f, c) = crypt2.getKeys()
if args.keys:
db.beginTransaction()
db.setToken(crypt2.createToken())
Util.saveKeys(args.keys, db.getConfigValue("ClientID"), f, c)
db.commit()
else:
db.setKeys(crypt2.createToken(), f, c)
db.close()
return 0
except Exception as e:
logger.error(e)
return 1
def moveKeys(db, crypt):
try:
if args.keys is None:
logger.error("Must specify key file for key manipulation")
return 1
clientId = db.getConfigValue('ClientID')
salt, vkey = db.getSrpValues()
#(db, _) = getDB(crypt)
if args.extract:
(f, c) = db.getKeys()
if not (f and c):
raise Exception("Unable to retrieve keys from server. Aborting.")
Util.saveKeys(args.keys, clientId, f, c)
if args.deleteKeys:
db.setKeys(salt, vkey, None, None)
elif args.insert:
(f, c) = Util.loadKeys(args.keys, clientId)
logger.info("Keys: F: %s C: %s", f, c)
if not (f and c):
raise Exception("Unable to retrieve keys from key database. Aborting.")
db.setKeys(salt, vkey, f, c)
if args.deleteKeys:
Util.saveKeys(args.keys, clientId, None, None)
return 0
except TardisDB.AuthenticationException as e:
logger.error("Authentication failed. Bad password")
return 1
except Exception as e:
logger.error(e)
exceptionLogger.log(e)
return 1
def processArgs():
parser = argparse.ArgumentParser(
description='encrypt or decrypt filenames',
fromfile_prefix_chars='@',
add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument('--encrypt',
'-e',
dest='encrypt',
default=False,
action='store_true',
help='Encrypt names instead of decrypting')
parser.add_argument(
'--quiet',
'-q',
dest='quiet',
default=False,
action='store_true',
help="Only print the translation, not the input strings")
parser.add_argument('--help', '-h', action='help')
parser.add_argument('names',
nargs='*',
help="List of pathnames to decrypt")
Util.addGenCompletions(parser)
args = parser.parse_args(remaining)
return args
def main():
global logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('')
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile,
args.passwordprog)
(_, _, crypto) = Util.setupDataConnection(args.database, args.client,
password, args.keys, args.dbname,
args.dbdir)
data = args.names
if not data:
tty = os.isatty(0)
if not tty:
data = list(map(str.strip, sys.stdin.readlines()))
else:
data = reader(args.quiet)
for i in data:
if i:
if not args.quiet:
print(i, " \t => \t", end=' ')
try:
if (args.encrypt):
print(crypto.encryptPath(i))
else:
print(crypto.decryptPath(i))
except Exception as e:
print("Caught exception: " + str(e))
def processArgs():
parser = argparse.ArgumentParser(description='Generate a key backup',
fromfile_prefix_chars='@',
formatter_class=Util.HelpFormatter,
add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser, addcrypt=False)
parser.add_argument('--output',
'-o',
default=None,
dest='output',
required=True,
help='Output file')
parser.add_argument('--verbose',
'-v',
action='count',
default=0,
dest='verbose',
help='Increase the verbosity')
parser.add_argument('--version',
action='version',
version='%(prog)s ' + Tardis.__versionstring__,
help='Show the version')
parser.add_argument('--help', '-h', action='help')
Util.addGenCompletions(parser)
return parser.parse_args(remaining)
def moveKeys(db, crypt):
try:
if args.keys is None:
logger.error("Must specify key file for key manipulation")
return 1
clientId = db.getConfigValue('ClientID')
token = crypt.createToken()
#(db, _) = getDB(crypt)
if args.extract:
(f, c) = db.getKeys()
if not (f and c):
raise Exception(
"Unable to retrieve keys from server. Aborting.")
Util.saveKeys(args.keys, clientId, f, c)
if args.deleteKeys:
db.setKeys(token, None, None)
elif args.insert:
(f, c) = Util.loadKeys(args.keys, clientId)
logger.info("Keys: F: %s C: %s", f, c)
if not (f and c):
raise Exception(
"Unable to retrieve keys from key database. Aborting.")
db.setKeys(token, f, c)
if args.deleteKeys:
Util.saveKeys(args.keys, clientId, None, None)
return 0
except Exception as e:
logger.error(e)
logger.exception(e)
return 1
def changePassword(crypt, crypt2):
try:
(db, _) = getDB(crypt)
# Load the keys, and insert them into the crypt object, to decyrpt them
if args.keys:
(f, c) = Util.loadKeys(args.keys, db.getConfigValue('ClientID'))
else:
(f, c) = db.getKeys()
crypt.setKeys(f, c)
# Grab the keys from one crypt object.
# Need to do this because getKeys/setKeys assumes they're encrypted, and we need the raw
# versions
crypt2._filenameKey = crypt._filenameKey
crypt2._contentKey = crypt._contentKey
# Now get the encrypted versions
(f, c) = crypt2.getKeys()
if args.keys:
db.beginTransaction()
db.setToken(crypt2.createToken())
Util.saveKeys(args.keys, db.getConfigValue('ClientID'), f, c)
db.commit()
else:
db.setKeys(crypt2.createToken(), f, c)
return 0
except Exception as e:
logger.error(e)
return 1
def listFiles(db, crypt):
#print args
info = getBackupSet(db, args.backup, args.date, defaultCurrent=True)
#print info, info['backupset']
lastDir = '/'
lastDirInode = (-1, -1)
bset = info['backupset']
files = db.getNewFiles(info['backupset'], args.previous)
for fInfo in files:
name = _decryptFilename(fInfo['name'], crypt)
if not args.dirs and fInfo['dir']:
continue
dirInode = (fInfo['parent'], fInfo['parentdev'])
if dirInode == lastDirInode:
path = lastDir
else:
path = _path(db, crypt, bset, dirInode)
lastDirInode = dirInode
lastDir = path
if not args.fullname:
print "%s:" % (path)
if args.status:
status = '[New] ' if fInfo['chainlength'] == 0 else '[Delta] '
else:
status = ''
if args.fullname:
name = os.path.join(path, name)
if args.long:
mode = Util.filemode(fInfo['mode'])
group = Util.getGroupName(fInfo['gid'])
owner = Util.getUserId(fInfo['uid'])
mtime = Util.formatTime(fInfo['mtime'])
if fInfo['size'] is not None:
if args.human:
size = "%8s" % Util.fmtSize(fInfo['size'], formats=['','KB','MB','GB', 'TB', 'PB'])
else:
size = "%8d" % int(fInfo['size'])
else:
size = ''
print' %s%9s %-8s %-8s %8s %12s' % (status, mode, owner, group, size, mtime),
if args.cksums:
print ' %32s ' % (fInfo['checksum'] or ''),
if args.chnlen:
print ' %4s ' % (fInfo['chainlength']),
if args.inode:
print ' %-16s ' % ("(%s, %s)" % (fInfo['device'], fInfo['inode'])),
print name
else:
print " %s" % status,
if args.cksums:
print ' %32s ' % (fInfo['checksum'] or ''),
if args.chnlen:
print ' %4s ' % (fInfo['chainlength']),
if args.inode:
print ' %-16s ' % ("(%s, %s)" % (fInfo['device'], fInfo['inode'])),
print name
def main():
global args, logger
tardis = None
try:
args = processArgs()
logger = Util.setupLogging(args.verbose)
setColors(Defaults.getDefault('TARDIS_LS_COLORS'))
# Load any password info
password = Util.getPassword(args.password,
args.passwordfile,
args.passwordprog,
prompt="Password for %s: " % (args.client))
args.password = None
(tardis, _, crypt) = Util.setupDataConnection(args.database,
args.client, password,
args.keys, args.dbname,
args.dbdir)
setupDisplay(tardis)
if args.headers:
doprint("Client: %s DB: %s" % (args.client, args.database),
color=colors['name'],
eol=True)
if args.glob:
directories = []
for d in args.directories:
if not Util.isMagic(d):
directories.append(d)
else:
directories += globPath(os.path.abspath(d), tardis, crypt)
else:
directories = args.directories
for d in directories:
d = unicode(os.path.abspath(d).decode(fsEncoding))
if args.realpath:
d = os.path.realpath(d)
fInfos = collectFileInfo(d, tardis, crypt)
recurse = args.maxdepth if args.recurse else 0
processFile(d,
fInfos,
tardis,
crypt,
printContents=(not args.dirinfo),
recurse=recurse)
except KeyboardInterrupt:
pass
except Exception as e:
logger.error("Caught exception: %s", str(e))
if args.exceptions:
logger.exception(e)
finally:
if tardis:
tardis.close()
def listFiles(db, crypt):
#print args
info = getBackupSet(db, args.backup, args.date, defaultCurrent=True)
#print info, info['backupset']
lastDir = '/'
lastDirInode = (-1, -1)
bset = info['backupset']
files = db.getNewFiles(info['backupset'], args.previous)
for fInfo in files:
name = _decryptFilename(fInfo['name'], crypt)
if not args.dirs and fInfo['dir']:
continue
dirInode = (fInfo['parent'], fInfo['parentdev'])
if dirInode == lastDirInode:
path = lastDir
else:
path = _path(db, crypt, bset, dirInode)
lastDirInode = dirInode
lastDir = path
if not args.fullname:
print("%s:" % (path))
if args.status:
status = '[New] ' if fInfo['chainlength'] == 0 else '[Delta] '
else:
status = ''
if args.fullname:
name = os.path.join(path, name)
if args.long:
mode = Util.filemode(fInfo['mode'])
group = Util.getGroupName(fInfo['gid'])
owner = Util.getUserId(fInfo['uid'])
mtime = Util.formatTime(fInfo['mtime'])
if fInfo['size'] is not None:
if args.human:
size = "%8s" % Util.fmtSize(fInfo['size'], formats=['','KB','MB','GB', 'TB', 'PB'])
else:
size = "%8d" % int(fInfo['size'])
else:
size = ''
print(' %s%9s %-8s %-8s %8s %12s' % (status, mode, owner, group, size, mtime), end=' ')
if args.cksums:
print(' %32s ' % (fInfo['checksum'] or ''), end=' ')
if args.chnlen:
print(' %4s ' % (fInfo['chainlength']), end=' ')
if args.inode:
print(' %-16s ' % ("(%s, %s)" % (fInfo['device'], fInfo['inode'])), end=' ')
print(name)
else:
print(" %s" % status, end=' ')
if args.cksums:
print(' %32s ' % (fInfo['checksum'] or ''), end=' ')
if args.chnlen:
print(' %4s ' % (fInfo['chainlength']), end=' ')
if args.inode:
print(' %-16s ' % ("(%s, %s)" % (fInfo['device'], fInfo['inode'])), end=' ')
print(name)
def changePassword(crypt, oldpw):
try:
(db, _, crypt) = getDB(oldpw)
# Get the new password
try:
newpw = Util.getPassword(args.newpw,
args.newpwf,
args.newpwp,
prompt="New Password for %s: " %
(args.client),
allowNone=False,
confirm=True,
strength=True)
except Exception as e:
logger.critical(str(e))
if args.exceptions:
logger.exception(e)
return -1
scheme = db.getConfigValue('CryptoScheme', 1)
crypt2 = TardisCrypto.getCrypto(scheme, newpw, args.client)
# Load the keys, and insert them into the crypt object, to decyrpt them
if args.keys:
(f, c) = Util.loadKeys(args.keys, db.getConfigValue('ClientID'))
# No need to check here, loadKeys() throws exception if nothing set.
else:
(f, c) = db.getKeys()
if f is None or c is None:
logger.critical(
"No keys loaded from database. Please specify --keys as appropriate"
)
raise Exception("No keys loaded")
crypt.setKeys(f, c)
# Grab the keys from one crypt object.
# Need to do this because getKeys/setKeys assumes they're encrypted, and we need the raw
# versions
crypt2._filenameKey = crypt._filenameKey
crypt2._contentKey = crypt._contentKey
# Now get the encrypted versions
(f, c) = crypt2.getKeys()
(salt, vkey) = srp.create_salted_verification_key(args.client, newpw)
if args.keys:
db.beginTransaction()
db.setSrpValues(salt, vkey)
Util.saveKeys(args.keys, db.getConfigValue('ClientID'), f, c)
db.commit()
else:
db.setKeys(salt, vkey, f, c)
return 0
except Exception as e:
logger.error(str(e))
if args.exceptions:
logger.exception(e)
return 1
def main():
global logger
try:
parseArgs()
logger = Util.setupLogging(args.verbose)
if len(args.backup) > 2:
logger.error(args.backup)
logger.error("Too many backups (%d) specified. Only one or two allowed", len(args.backup))
sys.exit(1)
password = Util.getPassword(
args.password, args.passwordfile, args.passwordprog, prompt="Password for %s: " % (args.client)
)
args.password = None
(tardis, cache, crypt) = Util.setupDataConnection(
args.database, args.client, password, args.keys, args.dbname, args.dbdir
)
password = None
bsets = []
for i in args.backup:
bset = getBackupSet(tardis, i)
if bset:
logger.debug("Got backupset %s", str(bset))
logger.debug("backupset: %s", bset["backupset"])
bsets.append(bset)
else:
sys.exit(1)
if len(bsets) == 1:
bsets.append(None)
r = Regenerator.Regenerator(cache, tardis, crypt)
then = time.asctime(time.localtime(float(bsets[0]["starttime"]))) + " (" + bsets[0]["name"] + ")"
if bsets[1]:
now = time.asctime(time.localtime(float(bsets[1]["starttime"]))) + " (" + bsets[1]["name"] + ")"
else:
now = time.asctime() + " (filesystem)"
for f in args.files:
if bsets[1] is None and os.path.isdir(f):
diffDir(os.path.abspath(f), r, bsets, tardis, crypt, args.reduce, now, then, recurse=args.recurse)
else:
(i0, _) = getFileInfo(os.path.abspath(f), bsets[0]["backupset"], tardis, crypt, args.reduce)
if i0 and i0["dir"]:
(i1, _) = getFileInfo(os.path.abspath(f), bsets[1]["backupset"], tardis, crypt, args.reduce)
if i1 and i1["dir"]:
diffDir(
os.path.abspath(f), r, bsets, tardis, crypt, args.reduce, now, then, recurse=args.recurse
)
continue
diffFile(f, r, bsets, tardis, crypt, args.reduce, args.recurse, now, then)
except KeyboardInterrupt:
pass
except Exception as e:
logger.error("Caught exception: %s", str(e))
logger.exception(e)
def removeOrphans(db, cache):
if hasattr(cache, "removeOrphans"):
r = cache.removeOrphans()
logger.debug("Remove Orphans: %s %s", type(r), r)
count = r["count"]
size = r["size"]
rounds = r["rounds"]
else:
count, size, rounds = Util.removeOrphans(db, cache)
print "Removed %d orphans, for %s, in %d rounds" % (count, Util.fmtSize(size), rounds)
def removeOrphans(db, cache):
if hasattr(cache, 'removeOrphans'):
r = cache.removeOrphans()
logger.debug("Remove Orphans: %s %s", type(r), r)
count = r['count']
size = r['size']
rounds = r['rounds']
else:
count, size, rounds = Util.removeOrphans(db, cache)
print "Removed %d orphans, for %s, in %d rounds" % (count, Util.fmtSize(size), rounds)
def removeOrphans(db, cache):
if hasattr(cache, 'removeOrphans'):
r = cache.removeOrphans()
logger.debug("Remove Orphans: %s %s", type(r), r)
count = r['count']
size = r['size']
rounds = r['rounds']
else:
count, size, rounds = Util.removeOrphans(db, cache)
print "Removed %d orphans, for %s, in %d rounds" % (count, Util.fmtSize(size), rounds)
def processArgs():
isatty = os.isatty(sys.stdout.fileno())
parser = argparse.ArgumentParser(description='List Tardis File Versions', fromfile_prefix_chars='@', formatter_class=Util.HelpFormatter, add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument('--long', '-l', dest='long', default=False, action='store_true', help='Use long listing format.')
parser.add_argument('--hidden', '-a', dest='hidden', default=False, action='store_true', help='Show hidden files.')
parser.add_argument('--reverse', '-r', dest='reverse', default=False, action='store_true', help='Reverse the sort order')
parser.add_argument('--annotate', '-f', dest='annotate', default=False, action='store_true', help='Annotate files based on type.')
parser.add_argument('--size', '-s', dest='size', default=False, action='store_true', help='Show file sizes')
parser.add_argument('--human', '-H', dest='human', default=False, action='store_true', help='Format sizes for easy reading')
parser.add_argument('--dirinfo', '-d', dest='dirinfo', default=False, action='store_true', help='List directories, but not their contents')
parser.add_argument('--checksums', '-c',dest='cksums', default=False, action='store_true', help='Print checksums.')
parser.add_argument('--chainlen', '-L', dest='chnlen', default=False, action='store_true', help='Print chainlengths.')
parser.add_argument('--inode', '-i', dest='inode', default=False, action='store_true', help='Print inode numbers')
parser.add_argument('--versions', '-V', dest='versions', default='change', choices=['none', 'change', 'all', 'last'], help='Display all, changed, last, or no versions of files. Default: %(default)s')
parser.add_argument('--deletions', dest='deletions', default=True, action=Util.StoreBoolean, help='Show deletions. Default: %(default)s')
parser.add_argument('--broken', dest='broken', default=True, action=Util.StoreBoolean, help='Show broken files (missing data). Default: %(default)s')
parser.add_argument('--oneline', '-O', dest='oneline', default=False, action=Util.StoreBoolean, help='Display versions on one line with the name. Default: %(default)s')
parser.add_argument('--times', '-T', dest='checktimes', default=False, action=Util.StoreBoolean, help='Use file time changes when determining diffs. Default: %(default)s')
parser.add_argument('--metadata', '-M', dest='checkmeta', default=False, action=Util.StoreBoolean, help='Use any metadata changes when determining diffs. Default: %(default)s')
parser.add_argument('--headers', dest='headers', default=True, action=Util.StoreBoolean, help='Show headers. Default: %(default)s')
parser.add_argument('--colors', dest='colors', default=isatty, action=Util.StoreBoolean, help='Use colors. Default: %(default)s')
parser.add_argument('--columns', dest='columns', type=int, default=None , help='Number of columns to display')
parser.add_argument('--recurse', '-R', dest='recurse', default=False, action='store_true', help='List Directories Recurively')
parser.add_argument('--maxdepth', dest='maxdepth', default=sys.maxint, type=int, help='Maximum depth to recurse directories')
parser.add_argument('--glob', dest='glob', default=False, action=Util.StoreBoolean, help='Glob filenames')
parser.add_argument('--reduce', dest='reduce', default=0, type=int, const=sys.maxint, nargs='?',
help='Reduce paths by N directories. No value for smart reduction')
parser.add_argument('--realpath', dest='realpath', default=True, action=Util.StoreBoolean, help='Use the full path, expanding symlinks to their actual path components')
rangegrp = parser.add_mutually_exclusive_group()
rangegrp.add_argument('--range', dest='range', default=None, help="Use a range of backupsets. Format: 'Start:End' Start and End can be names or backupset numbers. Either value can be left off to indicate the first or last set respectively")
rangegrp.add_argument('--dates', dest='daterange', default=None, help="Use a range of dates for the backupsets. Format: 'Start:End'. Start and End are names which can be intepreted liberally. Either can be left off to indicate the first or last set respectively")
parser.add_argument('--exceptions', default=False, action=Util.StoreBoolean, dest='exceptions', help="Log full exception data");
parser.add_argument('--verbose', '-v', action='count', default=0, dest='verbose', help='Increase the verbosity')
parser.add_argument('--version', action='version', version='%(prog)s ' + Tardis.__versionstring__, help='Show the version')
parser.add_argument('--help', '-h', action='help')
parser.add_argument('directories', nargs='*', default='.', help='List of directories/files to list')
Util.addGenCompletions(parser)
return parser.parse_args(remaining)
def processArgs():
isatty = os.isatty(sys.stdout.fileno())
parser = argparse.ArgumentParser(description='List Tardis File Versions', fromfile_prefix_chars='@', formatter_class=Util.HelpFormatter, add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument('--long', '-l', dest='long', default=False, action='store_true', help='Use long listing format.')
parser.add_argument('--hidden', '-a', dest='hidden', default=False, action='store_true', help='Show hidden files.')
parser.add_argument('--reverse', '-r', dest='reverse', default=False, action='store_true', help='Reverse the sort order')
parser.add_argument('--annotate', '-f', dest='annotate', default=False, action='store_true', help='Annotate files based on type.')
parser.add_argument('--size', '-s', dest='size', default=False, action='store_true', help='Show file sizes')
parser.add_argument('--human', '-H', dest='human', default=False, action='store_true', help='Format sizes for easy reading')
parser.add_argument('--dirinfo', '-d', dest='dirinfo', default=False, action='store_true', help='List directories, but not their contents')
parser.add_argument('--checksums', '-c',dest='cksums', default=False, action='store_true', help='Print checksums.')
parser.add_argument('--chainlen', '-L', dest='chnlen', default=False, action='store_true', help='Print chainlengths.')
parser.add_argument('--inode', '-i', dest='inode', default=False, action='store_true', help='Print inode numbers')
parser.add_argument('--versions', '-V', dest='versions', default='change', choices=['none', 'change', 'all', 'last'], help='Display all, changed, last, or no versions of files. Default: %(default)s')
parser.add_argument('--deletions', dest='deletions', default=True, action=Util.StoreBoolean, help='Show deletions. Default: %(default)s')
parser.add_argument('--broken', dest='broken', default=True, action=Util.StoreBoolean, help='Show broken files (missing data). Default: %(default)s')
parser.add_argument('--oneline', '-O', dest='oneline', default=False, action=Util.StoreBoolean, help='Display versions on one line with the name. Default: %(default)s')
parser.add_argument('--times', '-T', dest='checktimes', default=False, action=Util.StoreBoolean, help='Use file time changes when determining diffs. Default: %(default)s')
parser.add_argument('--metadata', '-M', dest='checkmeta', default=False, action=Util.StoreBoolean, help='Use any metadata changes when determining diffs. Default: %(default)s')
parser.add_argument('--headers', dest='headers', default=True, action=Util.StoreBoolean, help='Show headers. Default: %(default)s')
parser.add_argument('--colors', dest='colors', default=isatty, action=Util.StoreBoolean, help='Use colors. Default: %(default)s')
parser.add_argument('--columns', dest='columns', type=int, default=None , help='Number of columns to display')
parser.add_argument('--recurse', '-R', dest='recurse', default=False, action='store_true', help='List Directories Recurively')
parser.add_argument('--maxdepth', dest='maxdepth', default=sys.maxsize, type=int, help='Maximum depth to recurse directories')
parser.add_argument('--glob', dest='glob', default=False, action=Util.StoreBoolean, help='Glob filenames')
parser.add_argument('--reduce', dest='reduce', default=0, type=int, const=sys.maxsize, nargs='?',
help='Reduce paths by N directories. No value for smart reduction')
parser.add_argument('--realpath', dest='realpath', default=True, action=Util.StoreBoolean, help='Use the full path, expanding symlinks to their actual path components')
rangegrp = parser.add_mutually_exclusive_group()
rangegrp.add_argument('--range', dest='range', default=None, help="Use a range of backupsets. Format: 'Start:End' Start and End can be names or backupset numbers. Either value can be left off to indicate the first or last set respectively")
rangegrp.add_argument('--dates', dest='daterange', default=None, help="Use a range of dates for the backupsets. Format: 'Start:End'. Start and End are names which can be intepreted liberally. Either can be left off to indicate the first or last set respectively")
parser.add_argument('--exceptions', default=False, action=Util.StoreBoolean, dest='exceptions', help="Log full exception data");
parser.add_argument('--verbose', '-v', action='count', default=0, dest='verbose', help='Increase the verbosity')
parser.add_argument('--version', action='version', version='%(prog)s ' + Tardis.__versionstring__, help='Show the version')
parser.add_argument('--help', '-h', action='help')
parser.add_argument('directories', nargs='*', default='.', help='List of directories/files to list')
Util.addGenCompletions(parser)
return parser.parse_args(remaining)
def processArgs():
parser = argparse.ArgumentParser(description='Encrypt the database',
add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument('--names',
dest='names',
action='store_true',
default=False,
help='Encrypt filenames. Default=%(default)s')
parser.add_argument('--dirs',
dest='dirs',
action='store_true',
default=False,
help='Generate directory hashes. Default=%(default)s')
parser.add_argument('--sigs',
dest='sigs',
action='store_true',
default=False,
help='Generate signature files. Default=%(default)s')
parser.add_argument('--files',
dest='files',
action='store_true',
default=False,
help='Encrypt files. Default=%(default)s')
parser.add_argument('--meta',
dest='meta',
action='store_true',
default=False,
help='Generate metadata files. Default=%(default)s')
parser.add_argument(
'--all',
dest='all',
action='store_true',
default=False,
help='Perform all encyrption steps. Default=%(default)s')
parser.add_argument('--help', '-h', action='help')
Util.addGenCompletions(parser)
args = parser.parse_args(remaining)
if (not (args.names or args.files or args.dirs or args.meta or args.all
or args.sigs)):
parser.error(
"Must specify at least one --names, --files, --dirs, --meta, or --all"
)
return args
def changePassword(crypt, oldpw) :
try:
(db, _, crypt) = getDB(crypt, oldpw)
# Get the new password
try:
newpw = Util.getPassword(args.newpw, args.newpwf, args.newpwp, prompt="New Password for %s: " % (args.client),
allowNone=False, confirm=True, strength=True)
except Exception as e:
logger.critical(str(e))
if args.exceptions:
logger.exception(e)
return -1
crypt2 = TardisCrypto.TardisCrypto(newpw, args.client)
# Load the keys, and insert them into the crypt object, to decyrpt them
if args.keys:
(f, c) = Util.loadKeys(args.keys, db.getConfigValue('ClientID'))
# No need to check here, loadKeys() throws exception if nothing set.
else:
(f, c) = db.getKeys()
if f is None or c is None:
logger.critical("No keys loaded from database. Please specify --keys as appropriate")
raise Exception("No keys loaded")
crypt.setKeys(f, c)
# Grab the keys from one crypt object.
# Need to do this because getKeys/setKeys assumes they're encrypted, and we need the raw
# versions
crypt2._filenameKey = crypt._filenameKey
crypt2._contentKey = crypt._contentKey
# Now get the encrypted versions
(f, c) = crypt2.getKeys()
(salt, vkey) = srp.create_salted_verification_key(args.client, newpw)
if args.keys:
db.beginTransaction()
db.setSrpValues(salt, vkey)
Util.saveKeys(args.keys, db.getConfigValue('ClientID'), f, c)
db.commit()
else:
db.setKeys(salt, vkey, f, c)
return 0
except Exception as e:
logger.error(str(e))
if args.exceptions:
logger.exception(e)
return 1
def collectDirContents2(tardis, dirList, crypt):
"""
Do the same thing as collectDirContents, just a lot faster, relying on the structure of the DB.
Create a set of directory "ranges", a range being a set of entries in the dirlist that a: all have
the same inode, and b: span a contiguous range of backupsets in the backupsets list (ie, if there are 3
backupsets in the range in backupsets, there also must be the same three entries in the dirlist). Then
query any directory entries that exist in here, and span each one over the approriate portions of the
range. Repeat for each range.
"""
contents = {}
for (x, y) in dirList:
contents[x['backupset']] = {}
names = set()
ranges = []
dirRange = []
prev = {}
dirHash = dict([(x['backupset'], y) for (x,y) in dirList])
# Detect the ranges
for bset in backupSets:
d = dirHash.setdefault(bset['backupset'])
# If we don't have an entry here, the range ends.
# OR if the inode is different from the previous
if prev and ((not d) or (prev['inode'] != d['inode']) or (prev['device'] != d['device'])):
if len(dirRange):
ranges.append(dirRange)
dirRange = []
if d:
dirRange.append(bset)
prev = d
if len(dirRange):
ranges.append(dirRange)
# Now, for each range, populate
for r in ranges:
first = r[0]['backupset']
last = r[-1]['backupset']
dinfo = dirHash[first]
#print "Reading for (%d, %d) : %d => %d" %(dinfo['inode'], dinfo['device'], first, last)
x = tardis.readDirectoryForRange((dinfo['inode'], dinfo['device']), first, last)
for y in x:
logger.debug("Processing %s", y['name'])
name = Util.asString(crypt.decryptFilename(y['name'])) if crypt else Util.asString(y['name'])
names.add(name)
for bset in r:
if y['firstset'] <= bset['backupset'] <= y['lastset']:
contents[bset['backupset']][name] = y
# and return what we've discovered
return (contents, names)
def main():
global args, logger
tardis = None
try:
args = processArgs()
logger = Util.setupLogging(args.verbose)
setColors(Defaults.getDefault('TARDIS_LS_COLORS'))
# Load any password info
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog, prompt="Password for %s: " % (args.client))
args.password = None
(tardis, _, crypt) = Util.setupDataConnection(args.database, args.client, password, args.keys, args.dbname, args.dbdir)
setupDisplay(tardis)
if args.headers:
doprint("Client: %s DB: %s" %(args.client, args.database), color=colors['name'], eol=True)
if args.glob:
directories = []
for d in args.directories:
if not Util.isMagic(d):
directories.append(d)
else:
directories += globPath(os.path.abspath(d), tardis, crypt)
else:
directories = args.directories
for d in directories:
d = os.path.abspath(d)
if args.realpath:
d = os.path.realpath(d)
fInfos = collectFileInfo(d, tardis, crypt)
recurse = args.maxdepth if args.recurse else 0
processFile(d, fInfos, tardis, crypt, printContents=(not args.dirinfo), recurse=recurse)
except KeyboardInterrupt:
pass
except TardisDB.AuthenticationException as e:
logger.error("Authentication failed. Bad password")
if args.exceptions:
logger.exception(e)
except Exception as e:
logger.error("Caught exception: %s", str(e))
if args.exceptions:
logger.exception(e)
finally:
if tardis:
tardis.close()
def collectDirContents2(tardis, dirList, crypt):
"""
Do the same thing as collectDirContents, just a lot faster, relying on the structure of the DB.
Create a set of directory "ranges", a range being a set of entries in the dirlist that a: all have
the same inode, and b: span a contiguous range of backupsets in the backupsets list (ie, if there are 3
backupsets in the range in backupsets, there also must be the same three entries in the dirlist). Then
query any directory entries that exist in here, and span each one over the approriate portions of the
range. Repeat for each range.
"""
contents = {}
for (x, y) in dirList:
contents[x['backupset']] = {}
names = set()
ranges = []
dirRange = []
prev = {}
dirHash = dict([(x['backupset'], y) for (x,y) in dirList])
# Detect the ranges
for bset in backupSets:
d = dirHash.setdefault(bset['backupset'])
# If we don't have an entry here, the range ends.
# OR if the inode is different from the previous
if prev and ((not d) or (prev['inode'] != d['inode']) or (prev['device'] != d['device'])):
if len(dirRange):
ranges.append(dirRange)
dirRange = []
if d:
dirRange.append(bset)
prev = d
if len(dirRange):
ranges.append(dirRange)
# Now, for each range, populate
for r in ranges:
first = r[0]['backupset']
last = r[-1]['backupset']
dinfo = dirHash[first]
#print "Reading for (%d, %d) : %d => %d" %(dinfo['inode'], dinfo['device'], first, last)
x = tardis.readDirectoryForRange((dinfo['inode'], dinfo['device']), first, last)
for y in x:
logger.debug("Processing %s", y['name'])
name = Util.asString(crypt.decryptFilename(y['name'])) if crypt else Util.asString(y['name'])
names.add(name)
for bset in r:
if y['firstset'] <= bset['backupset'] <= y['lastset']:
contents[bset['backupset']][name] = y
# and return what we've discovered
return (contents, names)
def main():
logging.basicConfig(level=logging.INFO)
crypto = None
token = None
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile,
args.passwordurl, args.passwordprog)
if password:
crypto = TardisCrypto.TardisCrypto(password, args.client)
path = os.path.join(args.database, args.client, args.dbname)
db = TardisDB.TardisDB(path, token=token, backup=False)
if crypto:
(a, b) = db.getKeys()
crypto.setKeys(a, b)
conn = db.conn
dirs = conn.execute(
"SELECT Name as name, Inode AS inode, Device AS device, FirstSet as firstset, LastSet AS lastset FROM Files JOIN Names ON Files.NameId = Names.NameId WHERE Dir = 1"
)
while True:
batch = dirs.fetchmany(1000)
if not batch:
break
for d in batch:
name = d['name']
inode = d['inode']
device = d['device']
firstset = d['firstset']
lastset = d['lastset']
files = db.readDirectory((inode, device), current=lastset)
(checksum, nfiles) = Util.hashDir(crypto, files, True)
print("%-20s (%d, %d) [%d %d] -- %s %d") % (
name, inode, device, firstset, lastset, checksum, nfiles)
ckinfo = db.getChecksumInfo(checksum)
if ckinfo:
cksid = ckinfo['checksumid']
else:
cksid = db.insertChecksumFile(checksum,
size=nfiles,
isFile=False)
db.updateDirChecksum((inode, device), cksid, current=lastset)
conn.commit()
def main():
global args
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog, prompt="Password for %s: " % (args.client))
(tardis, _, crypt) = Util.setupDataConnection(args.database, args.client, password, args.keys, args.dbname, args.dbdir)
(f, c) = crypt.getKeys()
client = tardis.getConfigValue('ClientID')
data = Util.mkKeyString(client, f, c)
qrfile = mkQrFile(data)
makePdf(args.output, qrfile.name, data, args.client)
return 0
def main():
global logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('')
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile,
args.passwordurl, args.passwordprog)
crypto = TardisCrypto.TardisCrypto(password, args.client)
token = crypto.createToken()
#logger.info("Created token: %s", token)
path = os.path.join(args.database, args.client, args.dbname)
db = TardisDB.TardisDB(path, token=token, backup=False)
(f, c) = db.getKeys()
crypto.setKeys(f, c)
cacheDir = CacheDir.CacheDir(os.path.join(args.database, args.client))
#if args.sigs:
# generateSignatures(db, cacheDir)
if args.filenames:
encryptFilenames(db, crypto)
if args.files:
encryptFiles(db, crypto, cacheDir)
if args.dirhash:
generateDirHashes(db, crypto, cacheDir)
if args.meta:
generateMetadata(db, cacheDir)
def encryptFile(checksum,
cacheDir,
cipher,
iv,
pad,
hmac,
nameHmac,
output=None):
f = cacheDir.open(checksum, 'rb')
if output == None:
output = checksum + '.enc'
o = cacheDir.open(output, 'wb')
o.write(iv)
nb = len(iv)
hmac.update(iv)
for chunk, eof in Util._chunks(f, 64 * 1024):
if eof:
chunk = pad(chunk)
ochunk = cipher.encrypt(chunk)
o.write(ochunk)
nb = nb + len(ochunk)
hmac.update(ochunk)
ochunk = hmac.digest()
o.write(ochunk)
nb = nb + len(ochunk)
o.close()
f.close()
return nb
def listBSets(db, crypt, cache):
global _regenerator
try:
if args.longinfo:
_regenerator = Regenerator.Regenerator(cache, db, crypt)
last = db.lastBackupSet()
print "%-30s %-4s %-6s %3s %-5s %-24s %-7s %6s %5s %8s %s" % ("Name", "Id", "Comp", "Pri", "Full", "Start", "Runtime", "Files", "Delta", "Size", "")
for bset in db.listBackupSets():
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(bset['starttime'])))
if bset['endtime'] is not None:
duration = str(datetime.timedelta(seconds = (int(float(bset['endtime']) - float(bset['starttime'])))))
else:
duration = ''
completed = 'Comp' if bset['completed'] else 'Incomp'
full = 'Full' if bset['full'] else 'Delta'
isCurrent = current if bset['backupset'] == last['backupset'] else ''
size = Util.fmtSize(bset['bytesreceived'], formats=['', 'KB', 'MB', 'GB', 'TB'])
print "%-30s %-4d %-6s %3d %-5s %-24s %-7s %6s %5s %8s %s" % (bset['name'], bset['backupset'], completed, bset['priority'], full, t, duration, bset['filesfull'], bset['filesdelta'], size, isCurrent)
if args.longinfo:
commandLine = getCommandLine(db, bset['commandline'])
if commandLine:
print " Command Line: %s" % (commandLine)
print
except TardisDB.AuthenticationException as e:
logger.error("Authentication failed. Bad password")
return 1
except Exception as e:
logger.error(e)
exceptionLogger.log(e)
return 1
def computeColumnWidth(names):
"""
Given a list of names, compute the columns widths
"""
if len(list(names)) == 0:
return (1, '%s')
longestName = max(list(map(len, names)), default=0)
if args.columns:
columns = args.columns
else:
if os.isatty(sys.stdout.fileno()):
(_, width) = Util.getTerminalSize()
logger.debug("Setting width to %d", width)
width -= 2 # lop a couple characters off the end to avoid annoying wraps in some cases.
columns = int(width / (longestName + 4))
if columns == 0:
columns = 1
else:
columns = 1
fmt = "%%-%ds " % (longestName + 2)
logger.debug("Setting columns to %d", columns)
return (columns, fmt)
def collectFileInfo(filename, tardis, crypt):
"""
Collect information about a file in all the backupsets
Note that we sometimes need to reduce the pathlength. It's done here, on a directory
by directory basis.
"""
lookup = crypt.encryptPath(filename) if crypt else filename
fInfos = {}
lInfo = {}
if filename == '/':
fInfos = makeFakeRootInfo()
elif args.reduce:
for bset in backupSets:
temp = lookup
temp = Util.reducePath(tardis, bset['backupset'], temp, args.reduce) # No crypt, as we've already run that to get to lookup
if lInfo and lInfo['firstset'] <= bset['backupset'] <= lInfo['lastset']:
fInfos[bset['backupset']] = lInfo
else:
lInfo = tardis.getFileInfoByPath(temp, bset['backupset'])
fInfos[bset['backupset']] = lInfo
else:
fSet = backupSets[0]['backupset']
lSet = backupSets[-1]['backupset']
for (bset, info) in tardis.getFileInfoByPathForRange(lookup, fSet, lSet):
fInfos[bset] = info
return fInfos
def collectFileInfo(filename, tardis, crypt):
"""
Collect information about a file in all the backupsets
Note that we sometimes need to reduce the pathlength. It's done here, on a directory
by directory basis.
"""
lookup = crypt.encryptPath(filename) if crypt else filename
fInfos = {}
lInfo = {}
if filename == '/':
fInfos = makeFakeRootInfo()
elif args.reduce:
for bset in backupSets:
temp = lookup
temp = Util.reducePath(tardis, bset['backupset'], temp, args.reduce) # No crypt, as we've already run that to get to lookup
if lInfo and lInfo['firstset'] <= bset['backupset'] <= lInfo['lastset']:
fInfos[bset['backupset']] = lInfo
else:
lInfo = tardis.getFileInfoByPath(temp, bset['backupset'])
fInfos[bset['backupset']] = lInfo
else:
fSet = backupSets[0]['backupset']
lSet = backupSets[-1]['backupset']
for (bset, info) in tardis.getFileInfoByPathForRange(lookup, fSet, lSet):
logger.debug("Bset: %s, info: %s", bset, info)
fInfos[bset] = info
return fInfos
def listBSets(db):
try:
last = db.lastBackupSet()
for i in db.listBackupSets():
t = time.strftime("%d %b, %Y %I:%M:%S %p", time.localtime(float(i["starttime"])))
if i["endtime"] is not None:
duration = str(datetime.timedelta(seconds=(int(float(i["endtime"]) - float(i["starttime"])))))
else:
duration = ""
completed = "Comp" if i["completed"] else "Incomp"
full = "Full" if i["full"] else "Delta"
isCurrent = current if i["backupset"] == last["backupset"] else ""
size = Util.fmtSize(i["bytesreceived"], formats=["", "KB", "MB", "GB", "TB"])
print "%-30s %-4d %-6s %3d %-5s %s %-7s %6s %5s %8s %s" % (
i["name"],
i["backupset"],
completed,
i["priority"],
full,
t,
duration,
i["filesfull"],
i["filesdelta"],
size,
isCurrent,
)
except Exception as e:
logger.error(e)
logger.exception(e)
return 1
def listBSets(db):
try:
last = db.lastBackupSet()
for bset in db.listBackupSets():
t = time.strftime("%d %b, %Y %I:%M:%S %p",
time.localtime(float(bset['starttime'])))
if bset['endtime'] is not None:
duration = str(
datetime.timedelta(seconds=(
int(float(bset['endtime']) -
float(bset['starttime'])))))
else:
duration = ''
completed = 'Comp' if bset['completed'] else 'Incomp'
full = 'Full' if bset['full'] else 'Delta'
isCurrent = current if bset['backupset'] == last[
'backupset'] else ''
size = Util.fmtSize(bset['bytesreceived'],
formats=['', 'KB', 'MB', 'GB', 'TB'])
print "%-30s %-4d %-6s %3d %-5s %s %-7s %6s %5s %8s %s" % (
bset['name'], bset['backupset'], completed, bset['priority'],
full, t, duration, bset['filesfull'], bset['filesdelta'], size,
isCurrent)
except Exception as e:
logger.error(e)
logger.exception(e)
return 1
def computeColumnWidth(names):
"""
Given a list of names, compute the columns widths
"""
if len(list(names)) == 0:
return (1, '%s')
longestName = max(list(map(len, names)), default=0)
if args.columns:
columns = args.columns
else:
if os.isatty(sys.stdout.fileno()):
(_, width) = Util.getTerminalSize()
logger.debug("Setting width to %d", width)
width -= 2 # lop a couple characters off the end to avoid annoying wraps in some cases.
columns = int(width / (longestName + 4))
if columns == 0:
columns = 1
else:
columns = 1
fmt = "%%-%ds " % (longestName + 2)
logger.debug("Setting columns to %d", columns)
return (columns, fmt)
def generateMetadata(db, cacheDir):
conn = db.conn
r = conn.execute("SELECT COUNT(*) FROM CheckSums WHERE IsFile = 1")
n = r.fetchone()[0]
c = conn.cursor()
r = c.execute("SELECT Checksum, Size, Compressed, Encrypted, DiskSize, Basis FROM Checksums WHERE IsFile = 1 ORDER BY CheckSum")
metas = 0
logger.info("Generating metadata/recovery info for %d files", n)
with progressbar.ProgressBar(max_value=int(n)) as bar:
batch = r.fetchmany(4096)
while batch:
for row in batch:
# recordMetaData(cache, checksum, size, compressed, encrypted, disksize, basis=None, logger=None):
Util.recordMetaData(cacheDir, row[0], row[1], row[2], row[3], row[4], basis=row[5], logger=logger)
metas += 1
bar.update(metas)
batch = r.fetchmany(4096)
def processArgs():
parser = argparse.ArgumentParser(description='Generate a key backup', fromfile_prefix_chars='@', formatter_class=Util.HelpFormatter, add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser, addcrypt=False)
parser.add_argument('--output', '-o', default=None, dest='output', required=True, help='Output file')
parser.add_argument('--verbose', '-v', action='count', default=0, dest='verbose', help='Increase the verbosity')
parser.add_argument('--version', action='version', version='%(prog)s ' + Tardis.__versionstring__, help='Show the version')
parser.add_argument('--help', '-h', action='help')
Util.addGenCompletions(parser)
return parser.parse_args(remaining)
def main():
logging.basicConfig(level=logging.INFO)
crypto = None
token = None
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile, args.passwordurl, args.passwordprog)
if password:
crypto = TardisCrypto.TardisCrypto(password, args.client)
token = crypto.createToken()
path = os.path.join(args.database, args.client, args.dbname)
db = TardisDB.TardisDB(path, token=token, backup=False)
if crypto:
(a, b) = db.getKeys()
crypto.setKeys(a, b)
conn = db.conn
dirs = conn.execute("SELECT Name as name, Inode AS inode, Device AS device, FirstSet as firstset, LastSet AS lastset FROM Files JOIN Names ON Files.NameId = Names.NameId WHERE Dir = 1")
while True:
batch = dirs.fetchmany(1000)
if not batch:
break
for d in batch:
name = d['name']
inode = d['inode']
device = d['device']
firstset = d['firstset']
lastset = d['lastset']
files = db.readDirectory((inode, device), current=lastset)
names = [x['name'] for x in files]
nfiles = len(names)
if nfiles:
if crypto:
names = map(crypto.decryptFilename, names)
name = crypto.decryptFilename(name)
names = sorted(names)
m = hashlib.md5()
for f in names:
m.update(f)
checksum = m.hexdigest()
else:
checksum = 'd41d8cd98f00b204e9800998ecf8427e'
print("%-20s (%d, %d) [%d %d] -- %s %d") % (name, inode, device, firstset, lastset, checksum, nfiles)
ckinfo = db.getChecksumInfo(checksum)
if ckinfo:
cksid = ckinfo['checksumid']
else:
cksid = db.insertChecksumFile(checksum, size=nfiles, isFile=False)
db.updateDirChecksum((inode, device), cksid, current=lastset)
conn.commit()
def processArgs():
parser = argparse.ArgumentParser(description='encrypt or decrypt filenames', fromfile_prefix_chars='@', add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser, addcrypt=False)
parser.add_argument('--encrypt', '-e', dest='encrypt', default=False, action='store_true', help='Encrypt names instead of decrypting')
parser.add_argument('--quiet', '-q', dest='quiet', default=False, action='store_true', help="Only print the translation, not the input strings")
parser.add_argument('--help', '-h', action='help');
parser.add_argument('names', nargs='*', help="List of pathnames to decrypt")
Util.addGenCompletions(parser)
args = parser.parse_args(remaining)
return args
def processArgs():
parser = argparse.ArgumentParser(description='Decrypt a File', fromfile_prefix_chars='@', add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument('--output', '-o', type=argparse.FileType('wb'), default=sys.stdout.buffer, help='output file (default: stdout)')
parser.add_argument('--from_cache', '-c', default=False, action='store_true', help='Read a cached file')
parser.add_argument('--noauth', '-n', default=False, action='store_true', help='Do not authenticate file info')
parser.add_argument('--help', '-h', action='help');
parser.add_argument('name', nargs=1, help="Pathnames to decrypt")
Util.addGenCompletions(parser)
args = parser.parse_args(remaining)
return args
def main():
global args, logger
try:
FORMAT = "%(levelname)s : %(message)s"
logging.basicConfig(stream=sys.stderr, format=FORMAT, level=logging.INFO)
logger = logging.getLogger("")
args = processArgs()
setColors(Defaults.getDefault('TARDIS_LS_COLORS'))
# Load any password info
password = Util.getPassword(args.password, args.passwordfile, args.passwordprog, prompt="Password for %s: " % (args.client))
args.password = None
(tardis, _, crypt) = Util.setupDataConnection(args.database, args.client, password, args.keys, args.dbname, args.dbdir)
setupDisplay(tardis)
if args.headers:
doprint("Client: %s DB: %s" %(args.client, args.database), color=colors['name'], eol=True)
if args.glob:
directories = []
for d in args.directories:
if not Util.isMagic(d):
directories.append(d)
else:
directories += globPath(os.path.abspath(d), tardis, crypt)
else:
directories = args.directories
for d in directories:
d = os.path.abspath(d)
if args.realpath:
d = os.path.realpath(d)
fInfos = collectFileInfo(d, tardis, crypt)
recurse = args.maxdepth if args.recurse else 0
processFile(d, fInfos, tardis, crypt, printContents=(not args.dirinfo), recurse=recurse)
except KeyboardInterrupt:
pass
except Exception as e:
logger.error("Caught exception: %s", str(e))
logger.exception(e)
def parseArgs():
parser = argparse.ArgumentParser(description='Recover Backed Up Files', fromfile_prefix_chars='@', formatter_class=Util.HelpFormatter, add_help=False)
(_, remaining) = Config.parseConfigOptions(parser)
Config.addCommonOptions(parser)
Config.addPasswordOptions(parser)
parser.add_argument("--output", "-o", dest="output", help="Output file", default=None)
parser.add_argument("--checksum", "-c", help="Use checksum instead of filename", dest='cksum', action='store_true', default=False)
bsetgroup = parser.add_mutually_exclusive_group()
bsetgroup.add_argument("--backup", "-b", help="Backup set to use. Default: %(default)s", dest='backup', default=Defaults.getDefault('TARDIS_RECENT_SET'))
bsetgroup.add_argument("--date", "-d", help="Regenerate as of date", dest='date', default=None)
bsetgroup.add_argument("--last", "-l", dest='last', default=False, action='store_true', help="Regenerate the most recent version of the file")
parser.add_argument('--recurse', dest='recurse', default=True, action=Util.StoreBoolean, help='Recurse directory trees. Default: %(default)s')
parser.add_argument('--recovername', dest='recovername', default=False, action=Util.StoreBoolean, help='Recover the name when recovering a checksum. Default: %(default)s')
parser.add_argument('--authenticate', dest='auth', default=True, action=Util.StoreBoolean, help='Authenticate files while regenerating them. Default: %(default)s')
parser.add_argument('--authfail-action', dest='authfailaction', default='rename', choices=['keep', 'rename', 'delete'], help='Action to take for files that do not authenticate. Default: %(default)s')
parser.add_argument('--reduce-path', '-R', dest='reduce', default=0, const=sys.maxsize, type=int, nargs='?', metavar='N',
help='Reduce path by N directories. No value for "smart" reduction')
parser.add_argument('--set-times', dest='settime', default=True, action=Util.StoreBoolean, help='Set file times to match original file. Default: %(default)s')
parser.add_argument('--set-perms', dest='setperm', default=True, action=Util.StoreBoolean, help='Set file owner and permisions to match original file. Default: %(default)s')
parser.add_argument('--set-attrs', dest='setattrs', default=True, action=Util.StoreBoolean, help='Set file extended attributes to match original file. May only set attributes in user space. Default: %(default)s')
parser.add_argument('--set-acl', dest='setacl', default=True, action=Util.StoreBoolean, help='Set file access control lists to match the original file. Default: %(default)s')
parser.add_argument('--overwrite', '-O', dest='overwrite', default=owModeDefault, const='always', nargs='?',
choices=['always', 'newer', 'older', 'never', 'ask'],
help='Mode for handling existing files. Default: %(default)s')
parser.add_argument('--hardlinks', dest='hardlinks', default=True, action=Util.StoreBoolean, help='Create hardlinks of multiple copies of same inode created. Default: %(default)s')
parser.add_argument('--exceptions', default=False, action=Util.StoreBoolean, dest='exceptions', help="Log full exception data");
parser.add_argument('--verbose', '-v', action='count', default=0, dest='verbose', help='Increase the verbosity')
parser.add_argument('--version', action='version', version='%(prog)s ' + Tardis.__versionstring__, help='Show the version')
parser.add_argument('--help', '-h', action='help')
parser.add_argument('files', nargs='+', default=None, help="List of files to regenerate")
Util.addGenCompletions(parser)
return parser.parse_args(remaining)
def main():
logging.basicConfig(level=logging.INFO)
crypto = None
token = None
args = processArgs()
password = Util.getPassword(args.password, args.passwordfile, args.passwordurl, args.passwordprog)
if password:
crypto = TardisCrypto.TardisCrypto(password, args.client)
path = os.path.join(args.database, args.client, args.dbname)
db = TardisDB.TardisDB(path, token=token, backup=False)
if crypto:
(a, b) = db.getKeys()
crypto.setKeys(a, b)
conn = db.conn
dirs = conn.execute("SELECT Name as name, Inode AS inode, Device AS device, FirstSet as firstset, LastSet AS lastset FROM Files JOIN Names ON Files.NameId = Names.NameId WHERE Dir = 1")
while True:
batch = dirs.fetchmany(1000)
if not batch:
break
for d in batch:
name = d['name']
inode = d['inode']
device = d['device']
firstset = d['firstset']
lastset = d['lastset']
files = db.readDirectory((inode, device), current=lastset)
(checksum, nfiles) = Util.hashDir(crypto, files, True)
print(("%-20s (%d, %d) [%d %d] -- %s %d") % (name, inode, device, firstset, lastset, checksum, nfiles))
ckinfo = db.getChecksumInfo(checksum)
if ckinfo:
cksid = ckinfo['checksumid']
else:
cksid = db.insertChecksumFile(checksum, size=nfiles, isFile=False)
db.updateDirChecksum((inode, device), cksid, current=lastset)
conn.commit()
def setToken(crypt):
try:
# Must be no token specified yet
(db, _) = getDB(None)
crypt.genKeys()
(f, c) = crypt.getKeys()
token = crypt.createToken()
if args.keys:
db.beginTransaction()
db.setToken(token)
Util.saveKeys(args.keys, db.getConfigValue("ClientID"), f, c)
db.commit()
else:
db.setKeys(token, f, c)
db.close()
return 0
except Exception as e:
logger.error(e)
return 1
