Merge lp:~bit-team/backintime/password into lp:backintime/1.0

[Germar]

Add ability to store passwords in Backintime. There are three different modes:
-store password in system keyring
-store password in system keyring and cache it as soon as the user log in first time so it can be used during cronjobs if the user is logged out
- ask user for Password

[Dan (danleweb)]

review: Approve

=== modified file 'CHANGES'
--- CHANGES	2013-03-04 21:16:20 +0000
+++ CHANGES	2013-03-07 23:23:23 +0000
@@ -1,6 +1,7 @@
 Back In Time
 
 Version 1.0.22
+* Add Password storage mode ssh
 * Add "Full rsync mode" (can be faster but ...)
 * Fix bug: "Restore to..." failed due to spaces in directory name (https://bugs.launchpad.net/backintime/+bug/1096319)
 * Fix bug: host not found in known_hosts if port != 22 (https://bugs.launchpad.net/backintime/+bug/1130356)

=== modified file 'common/Makefile.template'
--- common/Makefile.template	2012-11-02 17:34:44 +0000
+++ common/Makefile.template	2013-03-07 23:23:23 +0000
@@ -38,4 +38,9 @@
 	#install application
 	install -d $(DEST)/bin
 	install backintime $(DEST)/bin
+	install backintime-askpass $(DEST)/bin
+
+	#install autostart
+	install -d $(DEST)/../etc/xdg/autostart
+	install --mode=644 backintime.desktop $(DEST)/../etc/xdg/autostart
 

=== added file 'common/askpass.py'
--- common/askpass.py	1970-01-01 00:00:00 +0000
+++ common/askpass.py	2013-03-07 23:23:23 +0000
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+#    Copyright (c) 2012-2013 Germar Reitze
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import os
+import sys
+import base64
+
+import password
+import password_ipc
+import tools
+import config
+
+if __name__ == '__main__':
+    """
+    return password.
+    """
+    cfg = config.Config()
+    tools.load_env(cfg)
+    try:
+        profile_id = os.environ['ASKPASS_PROFILE_ID']
+        mode = os.environ['ASKPASS_MODE']
+    except KeyError:
+        sys.exit(1)
+    try:
+        temp_file = os.environ['ASKPASS_TEMP']
+    except KeyError:
+        #normal mode, get password from module password
+        pw = password.Password(cfg)
+        print(pw.get_password(None, profile_id, mode))
+    else:
+        #temp mode
+        fifo = password_ipc.FIFO(temp_file)
+        pw_base64 = fifo.read(5)
+        if pw_base64:
+            print(base64.decodestring(pw_base64))
\ No newline at end of file

=== modified file 'common/backintime'
--- common/backintime	2009-11-02 13:52:00 +0000
+++ common/backintime	2013-03-07 23:23:23 +0000
@@ -23,5 +23,9 @@
 	APP_PATH="/usr/share/backintime/common"
 fi
 
-python $APP_PATH/backintime.py "$@"
+#starting a new ssh-agent all the time is just a workaround for
+#https://bugs.launchpad.net/ubuntu/+source/openssh/+bug/841672
+#normally this should only be necessary if run as cronjob
+#and the user is not logged in
+ssh-agent python $APP_PATH/backintime.py "$@"
 

=== added file 'common/backintime-askpass'
--- common/backintime-askpass	1970-01-01 00:00:00 +0000
+++ common/backintime-askpass	2013-03-07 23:23:23 +0000
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+#    Back In Time
+#    Copyright (C) 2008-2009 Oprea Dan, Bart de Koning, Richard Bailey
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+if [ -f askpass.py ]; then
+	APP_PATH="."
+else
+	APP_PATH="/usr/share/backintime/common"
+fi
+
+python $APP_PATH/askpass.py "$@"
+

=== added file 'common/backintime.desktop'
--- common/backintime.desktop	1970-01-01 00:00:00 +0000
+++ common/backintime.desktop	2013-03-07 23:23:23 +0000
@@ -0,0 +1,8 @@
+[Desktop Entry]
+Version=1.0
+Name=Backintime Password Cache
+Exec=backintime --pw-cache start
+Comment=Cache passwords for non-interactive Backintime cronjobs
+Icon=gtk-save
+Terminal=false
+Type=Application

=== modified file 'common/backintime.py'
--- common/backintime.py	2012-10-21 13:35:30 +0000
+++ common/backintime.py	2013-03-07 23:23:23 +0000
@@ -28,6 +28,7 @@
 import tools
 import sshtools
 import mount
+import password
 
 _=gettext.gettext
 
@@ -46,6 +47,7 @@
 
 def take_snapshot( cfg, force = True ):
 	logger.openlog()
+	tools.load_env(cfg)
 	_mount(cfg)
 	snapshots.Snapshots( cfg ).take_snapshot( force )
 	_umount(cfg)
@@ -105,6 +107,8 @@
 	print '\tUnmount the profile.'
 	print '--benchmark-cipher [file-size]'
 	print '\tShow a benchmark of all ciphers for ssh transfer (and exit)'
+	print '--pw-cache [start|stop|restart|reload|status]'
+	print '\tControl Password Cache for non-interactive cronjobs'
 	print '-v | --version'
 	print '\tShow version (and exit)'
 	print '--license'
@@ -251,6 +255,37 @@
 					print('ssh is not configured !')
 			sys.exit(0)
 
+		if arg == '--pw-cache':
+			if not cfg.is_configured():
+				print "The application is not configured !"
+				sys.exit(0)
+			else:
+				daemon = password.Password_Cache(cfg)
+				try:
+					if sys.argv[index + 1].startswith('-'):
+						daemon.run()
+					elif 'start' == sys.argv[index + 1]:
+						daemon.start()
+					elif 'stop' == sys.argv[index + 1]:
+						daemon.stop()
+					elif 'restart' == sys.argv[index + 1]:
+						daemon.restart()
+					elif 'reload' == sys.argv[index + 1]:
+						daemon.reload()
+					elif 'status' == sys.argv[index + 1]:
+						print 'Backintime Password Cache:',
+						if daemon.status():
+							print 'running'
+						else:
+							print 'not running'
+					else:
+						print "Unknown command"
+						print "usage: %s %s start|stop|restart|reload|status" % (sys.argv[0], sys.argv[index])
+						sys.exit(2)
+				except IndexError:
+					daemon.run()
+				sys.exit(0)
+
 		if arg == '--snapshots' or arg == '-s':
 			continue
 

=== modified file 'common/config.py'
--- common/config.py	2013-03-04 21:16:20 +0000
+++ common/config.py	2013-03-07 23:23:23 +0000
@@ -29,6 +29,7 @@
 import mount
 import sshtools
 ##import dummytools
+import password
 
 _=gettext.gettext
 
@@ -91,9 +92,11 @@
 	SNAPSHOT_MODES = {
 				#mode : (<mounttools>, _('ComboBox Text') ),
 				'local' : (None, _('Local') ),
-				'ssh' : (sshtools.SSH, _('SSH (without password)') )
+				'ssh' : (sshtools.SSH, _('SSH') )
 ##				'dummy' : (dummytools.Dummy, _('Dummy') )
 				}
+	
+	SNAPSHOT_MODES_NEED_PASSWORD = ['ssh', 'dummy']
 		
 	MOUNT_ROOT = '/tmp/backintime'
 	
@@ -219,6 +222,7 @@
 			self.save()
 		
 		self.current_hash_id = 'local'
+		self.pw = password.Password(self)
 
 	def save( self ):
 		configfile.ConfigFile.save( self, self._LOCAL_CONFIG_PATH )
@@ -449,6 +453,26 @@
 		if len(path) == 0:
 			path = './'
 		return (host, port, user, path)
+		
+	def get_ssh_private_key_file(self, profile_id = None):
+		ssh = self.get_ssh_private_key_folder()
+		default = ''
+		for file in ['id_dsa', 'id_rsa', 'identity']:
+			private_key = os.path.join(ssh, file)
+			if os.path.isfile(private_key):
+				default = private_key
+				break
+		file = self.get_profile_str_value( 'snapshots.ssh.private_key_file', default, profile_id )
+		if len(file) == 0:
+			return default
+		else:
+			return file
+
+	def get_ssh_private_key_folder(self):
+		return os.path.join(os.path.expanduser('~'), '.ssh')
+	
+	def set_ssh_private_key_file( self, value, profile_id = None ):
+		self.set_profile_str_value( 'snapshots.ssh.private_key_file', value, profile_id )
 
 ##	def get_dummy_host( self, profile_id = None ):
 ##		return self.get_profile_str_value( 'snapshots.dummy.host', '', profile_id )
@@ -468,6 +492,57 @@
 ##	def set_dummy_user( self, value, profile_id = None ):
 ##		self.set_profile_str_value( 'snapshots.dummy.user', value, profile_id )
 
+	def get_password_save( self, profile_id = None, mode = None ):
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		return self.get_profile_bool_value( 'snapshots.%s.password.save' % mode, True, profile_id )
+
+	def set_password_save( self, value, profile_id = None, mode = None ):
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		self.set_profile_bool_value( 'snapshots.%s.password.save' % mode, value, profile_id )
+
+	def get_password_use_cache( self, profile_id = None, mode = None ):
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		default = not tools.check_home_encrypt()
+		return self.get_profile_bool_value( 'snapshots.%s.password.use_cache' % mode, default, profile_id )
+
+	def set_password_use_cache( self, value, profile_id = None, mode = None ):
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		self.set_profile_bool_value( 'snapshots.%s.password.use_cache' % mode, value, profile_id )
+
+	def get_password( self, parent = None, profile_id = None, mode = None, only_from_keyring = False ):
+		if profile_id is None:
+			profile_id = self.get_current_profile()
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		return self.pw.get_password(parent, profile_id, mode, only_from_keyring)
+
+	def set_password( self, password, profile_id = None, mode = None ):
+		if profile_id is None:
+			profile_id = self.get_current_profile()
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		self.pw.set_password(password, profile_id, mode)
+
+	def get_keyring_backend(self):
+		return self.get_str_value('keyring.backend', '')
+
+	def set_keyring_backend(self, value):
+		self.set_str_value('keyring.backend', value)
+		
+	def get_keyring_service_name( self, profile_id = None, mode = None ):
+		if mode is None:
+			mode = self.get_snapshots_mode(profile_id)
+		return 'backintime/%s' % mode
+
+	def get_keyring_user_name( self, profile_id = None ):
+		if profile_id is None:
+			profile_id = self.get_current_profile()
+		return 'profile_id_%s' % profile_id
+
 	def get_auto_host_user_profile( self, profile_id = None ):
 		return self.get_profile_bool_value( 'snapshots.path.auto', True, profile_id )
 
@@ -891,6 +966,18 @@
 	def get_take_snapshot_user_callback( self, profile_id = None ):
 		return os.path.join( self._LOCAL_CONFIG_FOLDER, "user-callback" )
 
+	def get_password_cache_folder( self ):
+		return os.path.join( self._LOCAL_DATA_FOLDER, "password_cache" )
+
+	def get_password_cache_pid( self ):
+		return os.path.join( self.get_password_cache_folder(), "PID" )
+
+	def get_password_cache_fifo( self ):
+		return os.path.join( self.get_password_cache_folder(), "FIFO" )
+
+	def get_cron_env_file( self ):
+		return os.path.join( self._LOCAL_DATA_FOLDER, "cron_env" )
+
 	def get_license( self ):
 		return tools.read_file( os.path.join( self.get_doc_path(), 'LICENSE' ), '' )
 

=== modified file 'common/configfile.py'
--- common/configfile.py	2012-10-12 07:09:14 +0000
+++ common/configfile.py	2013-03-07 23:23:23 +0000
@@ -61,11 +61,11 @@
 		except:
 			pass
 
-	def load( self, filename ):
+	def load( self, filename, **kwargs ):
 		self.dict = {}
-		self.append( filename )
+		self.append( filename, **kwargs )
 
-	def append( self, filename ):
+	def append( self, filename, maxsplit = -1 ):
 		lines = []
 
 		try:
@@ -76,7 +76,7 @@
 			pass
 
 		for line in lines:
-			items = line.split( '=' )
+			items = line.split( '=', maxsplit )
 			if len( items ) == 2:
 				self.dict[ items[ 0 ] ] = items[ 1 ][ : -1 ]
 
@@ -137,6 +137,8 @@
 		for key in remove_keys:
 			del self.dict[ key ]
 
+	def get_keys(self):
+		return self.dict.keys()
 
 class ConfigFileWithProfiles( ConfigFile ):
 	def __init__( self, default_profile_name = '' ):

=== added file 'common/debian_specific/conffiles'
--- common/debian_specific/conffiles	1970-01-01 00:00:00 +0000
+++ common/debian_specific/conffiles	2013-03-07 23:23:23 +0000
@@ -0,0 +1,1 @@
+/etc/xdg/autostart/backintime.desktop

=== modified file 'common/debian_specific/control'
--- common/debian_specific/control	2013-01-01 20:26:37 +0000
+++ common/debian_specific/control	2013-03-07 23:23:23 +0000
@@ -6,7 +6,7 @@
 Maintainer: BIT Team <[e-mail]>
 Homepage: http://backintime.le-web.org
 Architecture: all
-Depends: python, rsync, cron, openssh-client, sshfs
+Depends: python, rsync, cron, openssh-client, sshfs, python-keyring
 Recommends: powermgmt-base
 Conflicts: backintime
 Replaces: backintime

=== modified file 'common/debian_specific/rules'
--- common/debian_specific/rules	2010-03-01 13:22:45 +0000
+++ common/debian_specific/rules	2013-03-07 23:23:23 +0000
@@ -38,6 +38,10 @@
 	#install application
 	#dh_installdirs /usr/bin
 	dh_install backintime /usr/bin
+	dh_install backintime-askpass /usr/bin
+
+	#install autostart
+	dh_install backintime.desktop /etc/xdg/autostart
 	
 	#install langs
 	[INSTALL_LANGS]

=== modified file 'common/dummytools.py'
--- common/dummytools.py	2012-10-23 19:26:20 +0000
+++ common/dummytools.py	2013-03-07 23:23:23 +0000
@@ -1,4 +1,4 @@
-#    Copyright (c) 2012 Germar Reitze
+#    Copyright (c) 2012-2013 Germar Reitze
 #
 #    This program is free software; you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
@@ -35,17 +35,18 @@
     be used exactly like they were in this class.
     Methodes from MountControl also can be overriden in here if you need
     something different."""
-    def __init__(self, cfg = None, profile_id = None, hash_id = None, tmp_mount = False, **kwargs):
+    def __init__(self, cfg = None, profile_id = None, hash_id = None, tmp_mount = False, parent = None **kwargs):
         self.config = cfg
         if self.config is None:
             self.config = config.Config()
             
         self.profile_id = profile_id
-        if not self.profile_id:
+        if self.profile_id is None:
             self.profile_id = self.config.get_current_profile()
             
         self.tmp_mount = tmp_mount
         self.hash_id = hash_id
+        self.parent = parent
             
         #init MountControl
         mount.MountControl.__init__(self)
@@ -62,6 +63,7 @@
         self.setattr_kwargs('user', self.config.get_dummy_user(self.profile_id), **kwargs)
         self.setattr_kwargs('host', self.config.get_dummy_host(self.profile_id), **kwargs)
         self.setattr_kwargs('port', self.config.get_dummy_port(self.profile_id), **kwargs)
+        self.setattr_kwargs('password', self.config.get_password(parent, self.profile_id), store = False, **kwargs)
             
         self.set_default_args()
         

=== modified file 'common/makedeb-src.sh'
--- common/makedeb-src.sh	2012-11-17 13:45:00 +0000
+++ common/makedeb-src.sh	2013-03-07 23:23:23 +0000
@@ -17,6 +17,10 @@
 
 #app
 cp backintime $DEST/
+cp backintime-askpass $DEST/
+
+#autostart
+cp backintime.desktop $DEST/
 
 #python files
 cp *.py $DEST/
@@ -44,6 +48,9 @@
 #debian: rules
 cp debian_specific/rules $DEST/debian
 
+#debian: conffiles
+cp debian_specific/conffiles $DEST/debian
+
 #add languages to rules
 for langfile in `ls po/*.po`; do
 	lang=`echo $langfile | cut -d/ -f2 | cut -d. -f1`

=== modified file 'common/man/C/backintime.1'
--- common/man/C/backintime.1	2013-01-01 20:26:37 +0000
+++ common/man/C/backintime.1	2013-03-07 23:23:23 +0000
@@ -83,9 +83,11 @@
 To prepare your user account for ssh-mode you have to add the user to group 'fuse' by typing 'sudo adduser <USER> fuse' in terminal.  To apply changes you have to logout and login again.
 .PP
 Next you have to create a password-less login to the remote host (for further informations look at http://www.debian-administration.org/articles/152).
-Type in terminal 'ssh-keygen -t rsa' hit enter for default path and keep the passphrase empty. 
-.PP
-Finally type 'ssh-copy-id -i ~/.ssh/id_rsa.pub <REMOTE_USER>@<HOST>' and enter your password on remote host.
+Type in terminal 'ssh-keygen -t dsa' hit enter for default path and enter a passphrase for the private key.
+.PP
+Finally type 'ssh-copy-id -i ~/.ssh/id_dsa.pub <REMOTE_USER>@<HOST>' and enter your password on remote host.
+.PP
+In Settingsdialog you need to set the host and remote user. If you enter a relative path (no leading / ) it will start from remote users homedir. The password has to be the passphrase for your private key.
 .PP
 .B Cipher
 (the algorithm used to encrypt the data during transfer)

=== modified file 'common/mount.py'
--- common/mount.py	2012-10-23 19:26:20 +0000
+++ common/mount.py	2013-03-07 23:23:23 +0000
@@ -1,4 +1,4 @@
-#    Copyright (c) 2012 Germar Reitze
+#    Copyright (c) 2012-2013 Germar Reitze
 #
 #    This program is free software; you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
@@ -24,6 +24,7 @@
 
 import config
 import logger
+import tools
 
 _=gettext.gettext
 
@@ -34,7 +35,7 @@
     pass
 
 class Mount(object):
-    def __init__(self, cfg = None, profile_id = None, tmp_mount = False):
+    def __init__(self, cfg = None, profile_id = None, tmp_mount = False, parent = None):
         self.config = cfg
         if self.config is None:
             self.config = config.Config()
@@ -44,6 +45,7 @@
             self.profile_id = self.config.get_current_profile()
             
         self.tmp_mount = tmp_mount
+        self.parent = parent
             
     def mount(self, mode = None, check = True, **kwargs):
         if mode is None:
@@ -56,7 +58,9 @@
             while True:
                 try:
                     mounttools = self.config.SNAPSHOT_MODES[mode][0]
-                    tools = mounttools(cfg = self.config, profile_id = self.profile_id, tmp_mount = self.tmp_mount, mode = mode, **kwargs)
+                    tools = mounttools(cfg = self.config, profile_id = self.profile_id,
+                                       tmp_mount = self.tmp_mount, mode = mode,
+                                       parent = self.parent, **kwargs)
                     return tools.mount(check = check)
                 except HashCollision as ex:
                     logger.warning(str(ex))
@@ -79,7 +83,9 @@
             kwargs = json.loads(data_string)
             mode = kwargs.pop('mode')
             mounttools = self.config.SNAPSHOT_MODES[mode][0]
-            tools = mounttools(cfg = self.config, profile_id = self.profile_id, tmp_mount = self.tmp_mount, mode = mode, hash_id = hash_id, **kwargs)
+            tools = mounttools(cfg = self.config, profile_id = self.profile_id,
+                               tmp_mount = self.tmp_mount, mode = mode,
+                               hash_id = hash_id, parent = self.parent, **kwargs)
             tools.umount()
         
     def pre_mount_check(self, mode = None, first_run = False, **kwargs):
@@ -93,7 +99,9 @@
             return True
         else:
             mounttools = self.config.SNAPSHOT_MODES[mode][0]
-            tools = mounttools(cfg = self.config, profile_id = self.profile_id, tmp_mount = self.tmp_mount, mode = mode, **kwargs)
+            tools = mounttools(cfg = self.config, profile_id = self.profile_id,
+                               tmp_mount = self.tmp_mount, mode = mode,
+                               parent = self.parent, **kwargs)
             return tools.pre_mount_check(first_run)
         
     def remount(self, new_profile_id, mode = None, hash_id = None, **kwargs):
@@ -117,7 +125,9 @@
             return self.mount(mode = mode, **kwargs)
             
         mounttools = self.config.SNAPSHOT_MODES[mode][0]
-        tools = mounttools(cfg = self.config, profile_id = new_profile_id, tmp_mount = self.tmp_mount, mode = mode, **kwargs)
+        tools = mounttools(cfg = self.config, profile_id = new_profile_id,
+                           tmp_mount = self.tmp_mount, mode = mode,
+                           parent = self.parent, **kwargs)
         if tools.compare_remount(hash_id):
             #profiles uses the same settings. just swap the symlinks
             tools.remove_symlink(profile_id = self.profile_id) 
@@ -214,14 +224,12 @@
         
     def is_mounted(self):
         """return True if path is is already mounted"""
-        try:
-            subprocess.check_call(['mountpoint', self.mountpoint], stdout=open(os.devnull, 'w'))
-        except subprocess.CalledProcessError:
+        if tools.check_mountpoint(self.mountpoint):
+            return True
+        else:
             if len(os.listdir(self.mountpoint)) > 0:
                 raise MountException( _('mountpoint %s not empty.') % self.mountpoint)
             return False
-        else:
-            return True
         
     def create_mountstructure(self):
         """ folder structure in /tmp/backintime/<user>/:
@@ -331,7 +339,7 @@
                         os.remove(os.path.join(self.mount_user_path, symlink))
         return False
             
-    def setattr_kwargs(self, arg, default, **kwargs):
+    def setattr_kwargs(self, arg, default, store = True, **kwargs):
         """if kwargs[arg] exist set self.<arg> to kwargs[arg]
            else set self.<arg> to default which should be the value from config"""
         if arg in kwargs:
@@ -339,8 +347,9 @@
         else:
             value = default
         setattr(self, arg, value)
-        #make dictionary with all used args for umount
-        self.all_kwargs[arg] = value
+        if store:
+            #make dictionary with all used args for umount
+            self.all_kwargs[arg] = value
             
     def write_umount_info(self):
         """dump dictionary self.all_kwargs to umount_info file"""
@@ -393,6 +402,8 @@
             src = mountpoint
         else:
             src = os.path.join(mountpoint, self.symlink_subfolder)
+        if os.path.exists(dst):
+            os.remove(dst)
         os.symlink(src, dst)
         
     def remove_symlink(self, profile_id = None, tmp_mount = None):

=== added file 'common/password.py'
--- common/password.py	1970-01-01 00:00:00 +0000
+++ common/password.py	2013-03-07 23:23:23 +0000
@@ -0,0 +1,446 @@
+#    Copyright (c) 2012-2013 Germar Reitze
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import sys
+import os
+import time
+import atexit
+import signal
+import base64
+import subprocess
+import gettext
+import keyring
+
+import config
+import configfile
+import tools
+import password_ipc
+
+_=gettext.gettext
+
+class Daemon:
+    """
+    A generic daemon class.
+   
+    Usage: subclass the Daemon class and override the run() method
+    
+    Daemon Copyright by Sander Marechal
+    License CC BY-SA 3.0
+    http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/
+    """
+    def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/stdout', stderr='/dev/null'):
+        self.stdin = stdin
+        self.stdout = stdout
+        self.stderr = stderr
+        self.pidfile = pidfile
+   
+    def daemonize(self):
+        """
+        do the UNIX double-fork magic, see Stevens' "Advanced
+        Programming in the UNIX Environment" for details (ISBN 0201563177)
+        http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
+        """
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # exit first parent
+                sys.exit(0)
+        except OSError, e:
+            sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
+            sys.exit(1)
+
+        # decouple from parent environment
+        os.chdir("/")
+        os.setsid()
+        os.umask(0)
+
+        # do second fork
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # exit from second parent
+                sys.exit(0)
+        except OSError, e:
+            sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+            sys.exit(1)
+
+        # redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        si = file(self.stdin, 'r')
+        so = file(self.stdout, 'a+')
+        se = file(self.stderr, 'a+', 0)
+        os.dup2(si.fileno(), sys.stdin.fileno())
+        os.dup2(so.fileno(), sys.stdout.fileno())
+        os.dup2(se.fileno(), sys.stderr.fileno())
+
+        # write pidfile
+        sys.stdout.write('write pidfile\n')
+        atexit.register(self.delpid)
+        signal.signal(signal.SIGTERM, self._cleanup_handler)
+        pid = str(os.getpid())
+        with open(self.pidfile, 'w+') as pidfile:
+            pidfile.write("%s\n" % pid)
+        os.chmod(self.pidfile, 0600)
+
+    def _cleanup_handler(self, signum, frame):
+        self.fifo.delfifo()
+        self.delpid()
+        sys.exit(0)
+        
+    def delpid(self):
+        try:
+            os.remove(self.pidfile)
+        except:
+            pass
+
+    def start(self):
+        """
+        Start the daemon
+        """
+        # Check for a pidfile to see if the daemon already runs
+        try:
+            pf = file(self.pidfile,'r')
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+
+        if pid:
+            if tools.is_process_alive(pid):
+                message = "pidfile %s already exist. Daemon already running?\n"
+                sys.stderr.write(message % self.pidfile)
+                sys.exit(1)
+            else:
+                self.delpid()
+       
+        # Start the daemon
+        self.daemonize()
+        self.run()
+
+    def stop(self):
+        """
+        Stop the daemon
+        """
+        # Get the pid from the pidfile
+        try:
+            pf = file(self.pidfile,'r')
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+
+        if not pid:
+            message = "pidfile %s does not exist. Daemon not running?\n"
+            sys.stderr.write(message % self.pidfile)
+            return # not an error in a restart
+
+        # Try killing the daemon process       
+        try:
+            while 1:
+                os.kill(pid, signal.SIGTERM)
+                time.sleep(0.1)
+        except OSError, err:
+            if err.errno == 3:
+                if os.path.exists(self.pidfile):
+                    os.remove(self.pidfile)
+            else:
+                print err.strerror
+                sys.exit(1)
+
+    def restart(self):
+        """
+        Restart the daemon
+        """
+        self.stop()
+        self.start()
+        
+    def reload(self):
+        """
+        send SIGHUP signal to process
+        """
+        # Get the pid from the pidfile
+        try:
+            pf = file(self.pidfile,'r')
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+
+        if not pid:
+            message = "pidfile %s does not exist. Daemon not running?\n"
+            sys.stderr.write(message % self.pidfile)
+            return
+        
+        # Try killing the daemon process       
+        try:
+            os.kill(pid, signal.SIGHUP)
+        except OSError, err:
+            if err.errno == 3:
+                if os.path.exists(self.pidfile):
+                    os.remove(self.pidfile)
+            else:
+                sys.stderr.write(err.strerror)
+                sys.exit(1)
+        
+    def status(self):
+        """
+        return status
+        """
+        # Get the pid from the pidfile
+        try:
+            pf = file(self.pidfile,'r')
+            pid = int(pf.read().strip())
+            pf.close()
+        except IOError:
+            pid = None
+
+        if not pid:
+            return False
+        
+        # Try killing the daemon process       
+        try:
+            os.kill(pid, 0)
+        except OSError, err:
+            if err.errno == 3:
+                if os.path.exists(self.pidfile):
+                    os.remove(self.pidfile)
+                    return False
+            else:
+                sys.stderr.write(err.strerror)
+                return False
+        return True
+
+    def run(self):
+        """
+        You should override this method when you subclass Daemon. It will be called after the process has been
+        daemonized by start() or restart().
+        """
+        pass
+        
+class Password_Cache(Daemon):
+    """
+    Password_Cache get started on User login. It provides passwords for
+    BIT cronjobs because keyring is not available when the User is not
+    logged in. Does not start if there is no password to cache
+    (e.g. no profile allows to cache).
+    """
+    def __init__(self, cfg = None, *args, **kwargs):
+        self.config = cfg
+        if self.config is None:
+            self.config = config.Config()
+        pw_cache_path = self.config.get_password_cache_folder()
+        if not os.path.isdir(pw_cache_path):
+            os.mkdir(pw_cache_path, 0700)
+        else:
+            os.chmod(pw_cache_path, 0700)
+        Daemon.__init__(self, self.config.get_password_cache_pid(), *args, **kwargs)
+        self.db = {}
+        self.fifo = password_ipc.FIFO(self.config.get_password_cache_fifo())
+        
+        if self.config.get_keyring_backend() == 'kde':
+            keyring.set_keyring(keyring.backend.KDEKWallet())
+        else:
+            keyring.set_keyring(keyring.backend.GnomeKeyring())
+    
+    def run(self):
+        """
+        wait for password request on FIFO and answer with password
+        from self.db through FIFO.
+        """
+        tools.save_env(self.config)
+        if tools.check_home_encrypt():
+            sys.stdout.write('Home is encrypt. Doesn\'t make sense to cache passwords. Quit.')
+            sys.exit(0)
+        self._collect_passwords()
+        if len(self.db) == 0:
+            sys.stdout.write('Nothing to cache. Quit.')
+            sys.exit(0)
+        self.fifo.create()
+        atexit.register(self.fifo.delfifo)
+        signal.signal(signal.SIGHUP, self._reload_handler)
+        while True:
+            try:
+                request = self.fifo.read()
+                request = request.split('\n')[0]
+                if request in self.db.keys():
+                    answer = self.db[request]
+                else:
+                    answer = ''
+                self.fifo.write(answer, 5)
+            except IOError as e:
+                sys.stderr.write('Error in writing answer to FIFO: %s\n' % e.strerror)
+            except KeyboardInterrupt: 
+                print('Quit.')
+                break
+            except tools.Timeout:
+                sys.stderr.write('FIFO timeout\n')
+            except StandardError as e:
+                sys.stderr.write('ERROR: %s\n' % str(e))
+        
+    def _reload_handler(self, signum, frame):
+        """
+        reload passwords during runtime.
+        """
+        sys.stdout.write('Reloading\n')
+        del(self.db)
+        self.db = {}
+        self._collect_passwords()
+        
+    def _collect_passwords(self):
+        """
+        search all profiles in config and collect passwords from keyring.
+        """
+        profiles = self.config.get_profiles()
+        for profile_id in profiles:
+            mode = self.config.get_snapshots_mode(profile_id)
+            if mode in self.config.SNAPSHOT_MODES_NEED_PASSWORD:
+                if self.config.get_password_save(profile_id):
+                    if self.config.get_password_use_cache(profile_id):
+                        service_name = self.config.get_keyring_service_name(profile_id, mode)
+                        user_name = self.config.get_keyring_user_name(profile_id)
+                            
+                        password = keyring.get_password(service_name, user_name)
+                        if password is None:
+                            continue
+                        #add some snakeoil
+                        pw_base64 = base64.encodestring(password)
+                        self.db[profile_id] = pw_base64
+
+class Password(object):
+    """
+    provide passwords for BIT either from keyring, Password_Cache or 
+    by asking User.
+    """
+    def __init__(self, cfg = None):
+        self.config = cfg
+        if self.config is None:
+            self.config = config.Config()
+        self.pw_cache = Password_Cache(self.config)
+        self.fifo = password_ipc.FIFO(self.config.get_password_cache_fifo())
+        self.db = {}
+        
+        if self.config.get_keyring_backend() == 'kwallet':
+            keyring.set_keyring(keyring.backend.KDEKWallet())
+        else:
+            keyring.set_keyring(keyring.backend.GnomeKeyring())
+    
+    def get_password(self, parent, profile_id, mode, only_from_keyring = False):
+        """
+        based on profile settings return password from keyring,
+        Password_Cache or by asking User.
+        """
+        if not mode in self.config.SNAPSHOT_MODES_NEED_PASSWORD:
+            return ''
+        try:
+            return self.db[profile_id][mode]
+        except KeyError:
+            pass
+        if self.config.get_password_save(profile_id):
+            if self.config.get_password_use_cache(profile_id) and not only_from_keyring:
+                password = self._get_password_from_pw_cache(profile_id)
+            else:
+                password = self._get_password_from_keyring(profile_id, mode)
+        else:
+            if not only_from_keyring:
+                password = self._get_password_from_user(parent, profile_id, mode)
+            else:
+                password = ''
+        self._set_password_db(profile_id, mode, password)
+        return password
+        
+    def _get_password_from_keyring(self, profile_id, mode):
+        """
+        get password from system keyring (seahorse). The keyring is only
+        available if User is logged in.
+        """
+        service_name = self.config.get_keyring_service_name(profile_id, mode)
+        user_name = self.config.get_keyring_user_name(profile_id)
+        return keyring.get_password(service_name, user_name)
+    
+    def _get_password_from_pw_cache(self, profile_id):
+        """
+        get password from Password_Cache
+        """
+        if self.pw_cache:
+            self.fifo.write(profile_id, timeout = 5)
+            pw_base64 = self.fifo.read(timeout = 5)
+            return base64.decodestring(pw_base64)
+        else:
+            return ''
+    
+    def _get_password_from_user(self, parent, profile_id, mode):
+        """
+        ask user for password. This does even work when run as cronjob
+        and user is logged in.
+        """
+        prompt = _('Enter Password for profile \'%(profile)s\' mode %(mode)s: ') % {'profile': self.config.get_profile_name(profile_id), 'mode': self.config.SNAPSHOT_MODES[mode][1]}
+        
+        gnome = os.path.join(self.config.get_app_path(), 'gnome')
+        kde   = os.path.join(self.config.get_app_path(), 'kde4')
+        for path in (gnome, kde):
+            if os.path.isdir(path):
+                sys.path = [path] + sys.path
+                break
+        
+        x_server = tools.check_x_server()
+        import_successful = False
+        if x_server:
+            try:
+                import messagebox
+                import_successful = True
+            except ImportError:
+                pass
+            
+        if not import_successful or not x_server:
+            import getpass
+            alarm = tools.Alarm()
+            alarm.start(300)
+            try:
+                password = getpass.getpass(prompt)
+                alarm.stop()
+            except tools.Timeout:
+                password = ''
+            return password
+        
+        password = messagebox.ask_password_dialog(parent, self.config, 'Back in Time',
+                    prompt = prompt,
+                    timeout = 300)
+        return password
+        
+    def _set_password_db(self, profile_id, mode, password):
+        """
+        internal Password cache. Prevent to ask password several times
+        during runtime.
+        """
+        if not profile_id in self.db.keys():
+            self.db[profile_id] = {}
+        self.db[profile_id][mode] = password
+    
+    def set_password(self, password, profile_id, mode):
+        """
+        store password to keyring (seahorse). If caching is allowed
+        reload Password_Cache
+        """
+        if mode in self.config.SNAPSHOT_MODES_NEED_PASSWORD:
+            service_name = self.config.get_keyring_service_name(profile_id, mode)
+            user_name = self.config.get_keyring_user_name(profile_id)
+            if self.config.get_password_save(profile_id):
+                keyring.set_password(service_name, user_name, password)
+                if self.config.get_password_use_cache(profile_id):
+                    if self.pw_cache.status():
+                        self.pw_cache.reload()
+            self._set_password_db(profile_id, mode, password)

=== added file 'common/password_ipc.py'
--- common/password_ipc.py	1970-01-01 00:00:00 +0000
+++ common/password_ipc.py	2013-03-07 23:23:23 +0000
@@ -0,0 +1,112 @@
+#    Copyright (c) 2012-2013 Germar Reitze
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import os
+import sys
+import stat
+import signal
+import tools
+import threading
+import base64
+
+class FIFO(object):
+    """
+    interprocess-communication with named pipes
+    """
+    def __init__(self, fname):
+        self.fifo = fname
+        self.alarm = tools.Alarm()
+        
+    def delfifo(self):
+        """
+        remove FIFO
+        """
+        try:
+            os.remove(self.fifo)
+        except:
+            pass
+        
+    def create(self):
+        """
+        create the FIFO in a way that only the current user can access it.
+        """
+        if os.path.exists(self.fifo):
+            self.delfifo()
+        try:
+            os.mkfifo(self.fifo, 0600)
+        except OSError, e:
+            sys.stderr.write('Failed to create FIFO: %s\n' % e.strerror)
+            sys.exit(1)
+        
+    def read(self, timeout = 0):
+        """
+        read from fifo untill timeout. If timeout is 0 it will wait forever
+        for input.
+        """
+        #sys.stdout.write('read fifo\n')
+        if not self.is_fifo():
+            sys.stderr.write('%s is not a FIFO\n' % self.fifo)
+            sys.exit(1)
+        self.alarm.start(timeout)
+        with open(self.fifo, 'r') as fifo:
+            ret = fifo.read()
+        self.alarm.stop()
+        return ret
+        
+    def write(self, string, timeout = 0):
+        """
+        write to fifo untill timeout. If timeout is 0 it will wait forever
+        for an other process that will read this.
+        """
+        #sys.stdout.write('write fifo\n')
+        if not self.is_fifo():
+            sys.stderr.write('%s is not a FIFO\n' % self.fifo)
+            sys.exit(1)
+        self.alarm.start(timeout)
+        with open(self.fifo, 'a') as fifo:
+            fifo.write(string)
+        self.alarm.stop()
+        
+    def is_fifo(self):
+        """
+        make sure file is still a FIFO
+        """
+        try:
+            return stat.S_ISFIFO(os.stat(self.fifo).st_mode)
+        except OSError:
+            return False
+
+class TempPasswordThread(threading.Thread):
+    """
+    in case BIT is not configured yet provide password through temp FIFO
+    to backintime-askpass.
+    """
+    def __init__(self, string, temp_file):
+        threading.Thread.__init__(self)
+        self.pw_base64 = base64.encodestring(string)
+        self.fifo = FIFO(temp_file)
+        
+    def run(self):
+        self.fifo.create()
+        self.fifo.write(self.pw_base64)
+        self.fifo.delfifo()
+
+    def read(self):
+        """
+        read fifo to end the blocking fifo.write
+        use only if thread timeout.
+        """
+        self.fifo.read()
\ No newline at end of file

=== modified file 'common/sshtools.py'
--- common/sshtools.py	2013-02-20 16:37:48 +0000
+++ common/sshtools.py	2013-03-07 23:23:23 +0000
@@ -1,4 +1,4 @@
-#    Copyright (c) 2012 Germar Reitze
+#    Copyright (c) 2012-2013 Germar Reitze
 #
 #    This program is free software; you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
@@ -22,11 +22,13 @@
 import random
 import tempfile
 from time import sleep
+import threading
 
 import config
 import mount
 import logger
 import tools
+import password_ipc
 
 _=gettext.gettext
 
@@ -35,17 +37,18 @@
     Mount remote path with sshfs. The real take_snapshot process will use
     rsync over ssh. Other commands run remote over ssh.
     """
-    def __init__(self, cfg = None, profile_id = None, hash_id = None, tmp_mount = False, **kwargs):
+    def __init__(self, cfg = None, profile_id = None, hash_id = None, tmp_mount = False, parent = None, **kwargs):
         self.config = cfg
         if self.config is None:
             self.config = config.Config()
             
         self.profile_id = profile_id
-        if not self.profile_id:
+        if self.profile_id is None:
             self.profile_id = self.config.get_current_profile()
             
         self.tmp_mount = tmp_mount
         self.hash_id = hash_id
+        self.parent = parent
             
         #init MountControl
         mount.MountControl.__init__(self)
@@ -61,6 +64,8 @@
         self.setattr_kwargs('port', self.config.get_ssh_port(self.profile_id), **kwargs)
         self.setattr_kwargs('path', self.config.get_snapshots_path_ssh(self.profile_id), **kwargs)
         self.setattr_kwargs('cipher', self.config.get_ssh_cipher(self.profile_id), **kwargs)
+        self.setattr_kwargs('private_key_file', self.config.get_ssh_private_key_file(self.profile_id), **kwargs)
+        self.setattr_kwargs('password', None, store = False, **kwargs)
             
         if len(self.path) == 0:
             self.path = './'
@@ -70,6 +75,8 @@
         self.user_host_path = '%s@%s:%s' % (self.user, self.host, self.path)
         self.log_command = '%s: %s' % (self.mode, self.user_host_path)
         
+        self.unlock_ssh_agent()
+        
     def _mount(self):
         """mount the service"""
         sshfs = ['sshfs', '-p', str(self.port)]
@@ -125,6 +132,59 @@
            raise MountException( _('Error discription') ) if not"""
         return True
         
+    def unlock_ssh_agent(self):
+        """using askpass.py to unlock private key in ssh-agent"""
+        env = os.environ.copy()
+        env['SSH_ASKPASS'] = 'backintime-askpass'
+        env['ASKPASS_PROFILE_ID'] = self.profile_id
+        env['ASKPASS_MODE'] = self.mode
+        
+        output = subprocess.Popen(['ssh-add', '-l'], stdout = subprocess.PIPE).communicate()[0]
+        if not output.find(self.private_key_file) >= 0:
+            if not self.config.get_password_save(self.profile_id) and not tools.check_x_server():
+                #we need to unlink stdin from ssh-add in order to make it
+                #use our own backintime-askpass.
+                #But because of this we can NOT use getpass inside backintime-askpass
+                #if password is not saved and there is no x-server.
+                #So, let's just keep ssh-add asking for the password in that case.
+                alarm = tools.Alarm()
+                alarm.start(10)
+                try:
+                    proc = subprocess.call(['ssh-add', self.private_key_file])
+                    alarm.stop()
+                except tools.Timeout:
+                    pass
+            else:
+                if not self.password is None:
+                    #write password directly to temp FIFO
+                    temp_file = os.path.join(tempfile.mkdtemp(), 'FIFO')
+                    env['ASKPASS_TEMP'] = temp_file
+                    thread = password_ipc.TempPasswordThread(self.password, temp_file)
+                    thread.start()
+                
+                proc = subprocess.Popen(['ssh-add', self.private_key_file],
+                                        stdin=subprocess.PIPE,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE,
+                                        env = env,
+                                        preexec_fn = os.setsid)
+                output, error = proc.communicate()
+                if proc.returncode:
+                    print( _('Failed to unlock SSH private key:\nError: %s') % error)
+            output = subprocess.Popen(['ssh-add', '-l'], stdout = subprocess.PIPE).communicate()[0]
+            if not output.find(self.private_key_file) >= 0:
+                raise mount.MountException( _('Could not unlock ssh private key. Wrong password or password not available for cron.'))
+        
+            if not self.password is None:
+                thread.join(5)
+                if thread.isAlive():
+                    #threading does not support signal.alarm
+                    thread.read()
+                try:
+                    os.rmdir(os.path.dirname(temp_file))
+                except OSError:
+                    pass
+        
     def check_fuse(self):
         """check if sshfs is installed and user is part of group fuse"""
         if not self.pathexists('sshfs'):

=== modified file 'common/tools.py'
--- common/tools.py	2012-10-19 15:47:27 +0000
+++ common/tools.py	2013-03-07 23:23:23 +0000
@@ -22,7 +22,9 @@
 import subprocess
 import hashlib
 import commands
+import signal
 
+import configfile
 
 ON_AC = 0
 ON_BATTERY = 1
@@ -420,8 +422,73 @@
     except ValueError:
         return False
 
-#
-#
+def check_mountpoint(path):
+    '''return True if path is a mountpoint'''
+    try:
+        subprocess.check_call(['mountpoint', path], stdout=open(os.devnull, 'w'))
+    except subprocess.CalledProcessError:
+        return False
+    return True
+
+def check_home_encrypt():
+    '''return True if users home is encrypted'''
+    home = os.path.expanduser('~')
+    if not check_mountpoint(home):
+        return False
+    if check_command('ecryptfs-verify'):
+        try:
+            subprocess.check_call(['ecryptfs-verify', '--home'],
+                                    stdout=open(os.devnull, 'w'),
+                                    stderr=open(os.devnull, 'w'))
+        except subprocess.CalledProcessError:
+            pass
+        else:
+            return True
+    if check_command('encfs'):
+        mount = subprocess.Popen(['mount'], stdout=subprocess.PIPE).communicate()[0]
+        for line in mount.split('\n'):
+            line_split = line.split(' ')
+            if len(line_split) < 5:
+                continue
+            if not line_split[2] == home:
+                continue
+            if line_split[4] == 'fuse.encfs':
+                return True
+    return False
+
+def load_env(cfg):
+    env = os.environ.copy()
+    env_file = configfile.ConfigFile()
+    env_file.load(cfg.get_cron_env_file(), maxsplit = 1)
+    for key in env_file.get_keys():
+        value = env_file.get_str_value(key)
+        if not value:
+            continue
+        if not key in env.keys():
+            os.environ[key] = value
+    del(env_file)
+
+def save_env(cfg):
+    """
+    save environ variables to file that are needed by cron
+    to connect to keyring. This will only work if the user is logged in.
+    """
+    env = os.environ.copy()
+    env_file = configfile.ConfigFile()
+    #ubuntu
+    set_env_key(env, env_file, 'GNOME_KEYRING_CONTROL')
+    set_env_key(env, env_file, 'DBUS_SESSION_BUS_ADDRESS')
+    set_env_key(env, env_file, 'DISPLAY')
+    #debian
+    set_env_key(env, env_file, 'XAUTHORITY')
+    
+    env_file.save(cfg.get_cron_env_file())
+    del(env_file)
+
+def set_env_key(env, env_file, key):
+    if key in env.keys():
+        env_file.set_str_value(key, env[key])
+
 class UniquenessSet:
     '''a class to check for uniqueness of snapshots of the same [item]'''
     
@@ -474,3 +541,40 @@
         if verb: print " >> skip (it's a duplicate)" 
         return False
 
+class Timeout(Exception):
+    pass
+
+class Alarm(object):
+    """
+    Timeout for FIFO. This does not work with threading.
+    """
+    def __init__(self, callback = None):
+        self.callback = callback
+        
+    def start(self, timeout):
+        """
+        start timer
+        """
+        try:
+            signal.signal(signal.SIGALRM, self.handler)
+            signal.alarm(timeout)
+        except ValueError:
+            pass
+        
+    def stop(self):
+        """
+        stop timer before it come to an end
+        """
+        try:
+            signal.alarm(0)
+        except:
+            pass
+        
+    def handler(self, signum, frame):
+        """
+        timeout occur.
+        """
+        if self.callback is None:
+            raise Timeout()
+        else:
+            self.callback()
\ No newline at end of file

=== modified file 'gnome/backintime-gnome'
--- gnome/backintime-gnome	2009-11-02 13:52:00 +0000
+++ gnome/backintime-gnome	2013-03-07 23:23:23 +0000
@@ -23,5 +23,8 @@
 	APP_PATH="/usr/share/backintime/gnome"
 fi
 
-python ${APP_PATH}/app.py "$@"
+#starting a new ssh-agent all the time is just a workaround for
+#https://bugs.launchpad.net/ubuntu/+source/openssh/+bug/841672
+#normally we don't need to start ssh-agent for backintime-gnome
+ssh-agent python ${APP_PATH}/app.py "$@"
 

=== modified file 'gnome/debian_specific/control'
--- gnome/debian_specific/control	2013-01-09 21:02:50 +0000
+++ gnome/debian_specific/control	2013-03-07 23:23:23 +0000
@@ -5,6 +5,6 @@
 Maintainer: BIT Team <[e-mail]>
 Architecture: all
 Homepage: http://backintime.le-web.org
-Depends: x11-utils, python-glade2, python-gnome2, python-notify, meld, gksu, libnotify-bin, backintime-common (>= 1.0.21~), backintime-notify (>= 1.0.21~)
+Depends: x11-utils, python-glade2, python-gnome2, python-notify, python-keyring-gnome | python-gnomekeyring, meld, gksu, libnotify-bin, backintime-common (>= 1.0.21~), backintime-notify (>= 1.0.21~)
 Description: Simple backup system for GNOME Desktop
  This is a GNOME GUI frontend for backintime-common.

=== modified file 'gnome/messagebox.py'
--- gnome/messagebox.py	2012-10-28 23:11:24 +0000
+++ gnome/messagebox.py	2013-03-07 23:23:23 +0000
@@ -23,6 +23,7 @@
 pygtk.require("2.0")
 import gtk
 import gettext
+import gobject
 
 import config
 
@@ -46,7 +47,7 @@
     dialog.destroy()
     return retVal
 
-def text_input_dialog( parent, config, title, default_value = '' ):
+def text_input_dialog( parent, config, title, default_value = '', prompt = None, hide_input = False , timeout = None):
     
     builder = gtk.Builder()
     builder.set_translation_domain('backintime')
@@ -58,15 +59,27 @@
 
     dialog = builder.get_object( 'TextInputDialog' )
     dialog.set_title( title )
-    dialog.set_transient_for( parent )
+    if not parent is None:
+        dialog.set_transient_for( parent )
+        
+    prompt_text = builder.get_object('prompt_text')
+    if not prompt is None:
+        prompt_text.set_text(prompt)
+        prompt_text.set_visible(True)
     
     edit = builder.get_object( 'edit_text' )
+    
+    if hide_input:
+        edit.set_visibility(False)
 
     if not default_value is None:
         edit.set_text( default_value )
 
     edit.grab_focus()
     
+    if not timeout is None:
+        gobject.timeout_add(1000 * timeout, dialog.destroy)
+    
     text = None
     if gtk.RESPONSE_OK == dialog.run():
         text = edit.get_text()
@@ -76,3 +89,8 @@
     dialog.destroy()
     return text  
 
+def ask_password_dialog(parent, config, title, prompt, timeout = None):
+    password = text_input_dialog(parent, config, title,
+                    prompt = prompt,
+                    hide_input = True, timeout = timeout)
+    return(password)

=== modified file 'gnome/settingsdialog.glade'
--- gnome/settingsdialog.glade	2013-03-04 21:16:20 +0000
+++ gnome/settingsdialog.glade	2013-03-07 23:23:23 +0000
@@ -475,31 +475,6 @@
                                     <property name="position">1</property>
                                   </packing>
                                 </child>
-                                <child>
-                                  <object class="GtkLabel" id="lbl_ssh_cipher">
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
-                                    <property name="xalign">1</property>
-                                    <property name="label" translatable="yes">Cipher:</property>
-                                    <property name="width_chars">8</property>
-                                  </object>
-                                  <packing>
-                                    <property name="expand">False</property>
-                                    <property name="fill">True</property>
-                                    <property name="position">2</property>
-                                  </packing>
-                                </child>
-                                <child>
-                                  <object class="GtkComboBox" id="combo_ssh_cipher">
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
-                                  </object>
-                                  <packing>
-                                    <property name="expand">True</property>
-                                    <property name="fill">True</property>
-                                    <property name="position">3</property>
-                                  </packing>
-                                </child>
                               </object>
                               <packing>
                                 <property name="expand">True</property>
@@ -507,6 +482,108 @@
                                 <property name="position">1</property>
                               </packing>
                             </child>
+                            <child>
+                              <object class="GtkExpander" id="expander_ssh">
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <child>
+                                  <object class="GtkHBox" id="hbox_ssh3">
+                                    <property name="visible">True</property>
+                                    <property name="can_focus">False</property>
+                                    <property name="spacing">2</property>
+                                    <child>
+                                      <object class="GtkLabel" id="lbl_ssh_cipher">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">False</property>
+                                        <property name="xalign">1</property>
+                                        <property name="label" translatable="yes">Cipher:</property>
+                                        <property name="width_chars">8</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkComboBox" id="combo_ssh_cipher">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">False</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">True</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="lbl_ssh_private_key_file">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">False</property>
+                                        <property name="xalign">1</property>
+                                        <property name="label" translatable="yes">Private key:</property>
+                                        <property name="width_chars">12</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkEntry" id="txt_ssh_private_key_file">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">True</property>
+                                        <property name="editable">False</property>
+                                        <property name="invisible_char">•</property>
+                                        <property name="primary_icon_activatable">False</property>
+                                        <property name="secondary_icon_activatable">False</property>
+                                        <property name="primary_icon_sensitive">True</property>
+                                        <property name="secondary_icon_sensitive">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">True</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkButton" id="btn_ssh_private_key_file">
+                                        <property name="visible">True</property>
+                                        <property name="can_focus">True</property>
+                                        <property name="receives_default">True</property>
+                                        <property name="use_action_appearance">False</property>
+                                        <signal name="clicked" handler="on_btn_ssh_private_key_file_clicked" swapped="no"/>
+                                        <child>
+                                          <object class="GtkImage" id="image_ssh_private_key_file">
+                                            <property name="visible">True</property>
+                                            <property name="can_focus">False</property>
+                                            <property name="stock">gtk-directory</property>
+                                          </object>
+                                        </child>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                </child>
+                                <child type="label">
+                                  <object class="GtkLabel" id="label_ssh_advanced">
+                                    <property name="visible">True</property>
+                                    <property name="can_focus">False</property>
+                                    <property name="label" translatable="yes">Advanced SSH Settings</property>
+                                  </object>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">True</property>
+                                <property name="fill">True</property>
+                                <property name="position">2</property>
+                              </packing>
+                            </child>
                           </object>
                         </child>
                       </object>
@@ -645,6 +722,87 @@
                   </packing>
                 </child>
                 <child>
+                  <object class="GtkFrame" id="password">
+                    <property name="can_focus">False</property>
+                    <property name="label_xalign">0</property>
+                    <property name="shadow_type">none</property>
+                    <child>
+                      <object class="GtkAlignment" id="alignment_password">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="left_padding">12</property>
+                        <child>
+                          <object class="GtkVBox" id="vbox_password">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="spacing">2</property>
+                            <child>
+                              <object class="GtkEntry" id="txt_password">
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="invisible_char">•</property>
+                                <property name="primary_icon_activatable">False</property>
+                                <property name="secondary_icon_activatable">False</property>
+                                <property name="primary_icon_sensitive">True</property>
+                                <property name="secondary_icon_sensitive">True</property>
+                              </object>
+                              <packing>
+                                <property name="expand">True</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkCheckButton" id="cb_password_save">
+                                <property name="label" translatable="yes">Save Password to Keyring</property>
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="receives_default">False</property>
+                                <property name="use_action_appearance">False</property>
+                                <property name="draw_indicator">True</property>
+                                <signal name="toggled" handler="on_cb_password_save_toggled" swapped="no"/>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkCheckButton" id="cb_password_use_cache">
+                                <property name="label" translatable="yes">Cache Password for Cron (Security issue: root can read password)</property>
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="receives_default">False</property>
+                                <property name="use_action_appearance">False</property>
+                                <property name="draw_indicator">True</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">2</property>
+                              </packing>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel" id="lbl_password">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="label" translatable="yes">&lt;b&gt;Password&lt;/b&gt;</property>
+                        <property name="use_markup">True</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">850</property>
+                  </packing>
+                </child>
+                <child>
                   <object class="GtkFrame" id="advanced">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>

=== modified file 'gnome/settingsdialog.py'
--- gnome/settingsdialog.py	2013-03-04 21:16:20 +0000
+++ gnome/settingsdialog.py	2013-03-07 23:23:23 +0000
@@ -26,12 +26,14 @@
 import gobject
 import datetime
 import gettext
+import subprocess
+import keyring
 
 import config
 import messagebox
 import tools
 import mount
-
+import password
 
 _=gettext.gettext
 
@@ -77,7 +79,9 @@
 				'on_btn_where_clicked': self.on_btn_where_clicked,
 				'on_cb_backup_mode_changed': self.on_cb_backup_mode_changed,
 				'on_cb_auto_host_user_profile_toggled': self.update_host_user_profile,
-				'on_combo_modes_changed': self.on_combo_modes_changed
+				'on_combo_modes_changed': self.on_combo_modes_changed,
+				'on_cb_password_save_toggled': self.update_password_save,
+				'on_btn_ssh_private_key_file_clicked': self.on_btn_ssh_private_key_file_clicked
 			}
 		
 		builder.connect_signals(signals)
@@ -139,6 +143,7 @@
 		self.txt_ssh_port = get('txt_ssh_port')
 		self.txt_ssh_user = get('txt_ssh_user')
 		self.txt_ssh_path = get('txt_ssh_path')
+		self.txt_private_key_file = get('txt_ssh_private_key_file')
 		
 		self.store_ssh_cipher = gtk.ListStore(str, str)
 		keys = self.config.SSH_CIPHERS.keys()
@@ -159,6 +164,13 @@
 ##		self.txt_dummy_port = get('txt_dummy_port')
 ##		self.txt_dummy_user = get('txt_dummy_user')
 
+		#password
+		self.frame_password = get('password')
+		self.txt_password = get('txt_password')
+		self.txt_password.set_visibility(False)
+		self.cb_password_save = get('cb_password_save')
+		self.cb_password_use_cache = get('cb_password_use_cache')
+
 		#automatic backup mode store
 		self.store_backup_mode = gtk.ListStore( str, int )
 		map = self.config.AUTOMATIC_BACKUP_MODES
@@ -413,6 +425,22 @@
 		else:
 			fcd.destroy()
 
+	def on_btn_ssh_private_key_file_clicked( self, button ): 
+		file = self.txt_private_key_file.get_text()
+		
+		fcd = gtk.FileChooserDialog( _('SSH private key'), self.dialog, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK) )
+		if len( file ) > 0:
+			fcd.set_filename( file )
+		else:
+			fcd.set_filename(self.config.get_ssh_private_key_folder())
+		
+		if fcd.run() == gtk.RESPONSE_OK:
+			new_file = tools.prepare_path( fcd.get_filename() )
+			fcd.destroy()
+			self.txt_private_key_file.set_text( new_file )
+		else:
+			fcd.destroy()
+
 	def on_cb_backup_mode_changed( self, *params ):
 		iter = self.cb_backup_mode.get_active_iter()
 		if iter is None:
@@ -459,6 +487,12 @@
 		self.lbl_profile.set_sensitive( value )
 		self.txt_profile.set_sensitive( value )
 		
+	def update_password_save(self, *params):
+		value = self.cb_password_save.get_active()
+		if value and tools.check_home_encrypt():
+			value = False
+		self.cb_password_use_cache.set_sensitive(value)
+		
 	def on_combo_modes_changed(self, *params):
 		iter = self.combo_modes.get_active_iter()
 		if iter is None:
@@ -472,6 +506,10 @@
 				else:
 					getattr(self, 'mode_%s' % mode).hide()
 			self.mode = active_mode
+		if active_mode in self.config.SNAPSHOT_MODES_NEED_PASSWORD:
+			self.frame_password.show()
+		else:
+			self.frame_password.hide()
 
 	def on_combo_profiles_changed( self, *params ):
 		if self.disable_combo_changed:
@@ -541,6 +579,7 @@
 		self.txt_ssh_port.set_text( str(self.config.get_ssh_port( self.profile_id )) )
 		self.txt_ssh_user.set_text( self.config.get_ssh_user( self.profile_id ) )
 		self.txt_ssh_path.set_text( self.config.get_snapshots_path_ssh( self.profile_id ) )
+		self.txt_private_key_file.set_text( self.config.get_ssh_private_key_file( self.profile_id ) )
 		#set chipher
 		i = 0
 		iter = self.store_ssh_cipher.get_iter_first()
@@ -557,6 +596,15 @@
 ##		self.txt_dummy_port.set_text( str(self.config.get_dummy_port( self.profile_id )) )
 ##		self.txt_dummy_user.set_text( self.config.get_dummy_user( self.profile_id ) )
 		
+		#password
+		password = self.config.get_password( profile_id = self.profile_id, mode = self.mode, only_from_keyring = True )
+		if password is None:
+			password = ''
+		self.txt_password.set_text(password)
+		self.cb_password_save.set_active( self.config.get_password_save( self.profile_id, self.mode ) )
+		self.cb_password_use_cache.set_active( self.config.get_password_use_cache( self.profile_id, self.mode ) )
+		self.update_password_save()
+		
 		#per directory schedule
 		#self.cb_per_directory_schedule.set_active( self.config.get_per_directory_schedule() )
 		
@@ -749,6 +797,9 @@
 				self.error_handler( _('Custom Hours can only be a comma seperate list of hours (e.g. 8,12,18,23) or */3 for periodic backups every 3 hours') )
 				return False
 
+		#password
+		password = self.txt_password.get_text()
+
 		mount_kwargs = {}
 		
 		#ssh settings
@@ -756,10 +807,18 @@
 		ssh_port = self.txt_ssh_port.get_text()
 		ssh_user = self.txt_ssh_user.get_text()
 		ssh_path = self.txt_ssh_path.get_text()
+		ssh_private_key_file = self.txt_private_key_file.get_text()
 		iter = self.combo_ssh_cipher.get_active_iter()
 		ssh_cipher = self.store_ssh_cipher.get_value( iter, 1 )
 		if mode == 'ssh':
-			mount_kwargs = { 'host': ssh_host, 'port': int(ssh_port), 'user': ssh_user, 'path': ssh_path, 'cipher': ssh_cipher }
+			mount_kwargs = {'host': ssh_host,
+							'port': int(ssh_port),
+							'user': ssh_user,
+							'path': ssh_path,
+							'cipher': ssh_cipher,
+							'private_key_file': ssh_private_key_file,
+							'password': password
+							}
 		
 ##		#dummy settings
 ##		dummy_host = self.txt_dummy_host.get_text()
@@ -769,7 +828,11 @@
 ##			#values must have exactly the same Type (str, int or bool) 
 ##			#as they are set in config or you will run into false-positive
 ##			#HashCollision warnings
-##			mount_kwargs = { 'host': dummy_host, 'port': int(dummy_port), 'user': dummy_user }
+##			mount_kwargs = {'host': dummy_host,
+##							'port': int(dummy_port),
+##							'user': dummy_user,
+##							'password': password
+##							}
 			
 		if not self.config.SNAPSHOT_MODES[mode][0] is None:
 			#pre_mount_check
@@ -805,12 +868,32 @@
 		self.config.set_ssh_user(ssh_user, self.profile_id)
 		self.config.set_snapshots_path_ssh(ssh_path, self.profile_id)
 		self.config.set_ssh_cipher(ssh_cipher, self.profile_id)
+		self.config.set_ssh_private_key_file(ssh_private_key_file, self.profile_id)
 
 ##		#save dummy
 ##		self.config.set_dummy_host(dummy_host, self.profile_id)
 ##		self.config.set_dummy_port(dummy_port, self.profile_id)
 ##		self.config.set_dummy_user(dummy_user, self.profile_id)
 
+		#save password
+		if self.cb_password_save.get_active():
+			if self.config.get_keyring_backend() == '':
+				self.config.set_keyring_backend('gnomekeyring')
+			if self.config.get_keyring_backend() == 'kwallet':
+				if keyring.backend.KDEKWallet().supported() == 1:
+					keyring.set_keyring(keyring.backend.KDEKWallet())
+				else:
+					self.config.set_keyring_backend('gnomekeyring')
+			if self.config.get_keyring_backend() == 'gnomekeyring':
+				if keyring.backend.GnomeKeyring().supported() == 1:
+					keyring.set_keyring(keyring.backend.GnomeKeyring())
+				else:
+					self.error_handler( _('Can\'t connect to gnomekeyring to save password'))
+					return False
+		self.config.set_password_save(self.cb_password_save.get_active(), self.profile_id, mode)
+		self.config.set_password_use_cache(self.cb_password_use_cache.get_active(), self.profile_id, mode)
+		self.config.set_password(password, self.profile_id, mode)
+
 		#if not msg is None:
 		#   messagebox.show_error( self.dialog, self.config, msg )
 		#   return False
@@ -1062,5 +1145,13 @@
 			return False
 		
 		self.config.save()
+
+		#start Password_Cache if not running
+		daemon = password.Password_Cache(self.config)
+		if not daemon.status():
+			try:
+				subprocess.check_call(['backintime', '--pw-cache', 'start'], stdout=open(os.devnull, 'w'))
+			except subprocess.CalledProcessError as e:
+				messagebox.show_error(self.dialog, self.config, _('start Password Cache failed: %s') % e.strerror)
 		return True
 	

=== modified file 'gnome/textinputdialog.glade'
--- gnome/textinputdialog.glade	2011-11-21 09:27:27 +0000
+++ gnome/textinputdialog.glade	2013-03-07 23:23:23 +0000
@@ -63,6 +63,19 @@
           </packing>
         </child>
         <child>
+          <object class="GtkLabel" id="prompt_text">
+            <property name="visible">False</property>
+            <property name="can_focus">False</property>
+            <property name="xalign">0</property>
+            <property name="label" translatable="yes">Text</property>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
           <object class="GtkEntry" id="edit_text">
             <property name="visible">True</property>
             <property name="can_focus">True</property>
@@ -72,7 +85,7 @@
           <packing>
             <property name="expand">False</property>
             <property name="fill">True</property>
-            <property name="position">1</property>
+            <property name="position">2</property>
           </packing>
         </child>
       </object>

=== modified file 'kde4/app.py'
--- kde4/app.py	2012-10-31 21:45:38 +0000
+++ kde4/app.py	2013-03-07 23:23:23 +0000
@@ -343,7 +343,7 @@
 		
 		#mount
 		try:
-			mnt = mount.Mount(cfg = self.config, profile_id = profile_id)
+			mnt = mount.Mount(cfg = self.config, profile_id = profile_id, parent = self)
 			hash_id = mnt.mount()
 		except mount.MountException as ex:
 			KMessageBox.error( self, QString.fromUtf8( str(ex) ) )
@@ -413,7 +413,7 @@
 		
 		#umount
 		try:
-			mnt = mount.Mount(cfg = self.config)
+			mnt = mount.Mount(cfg = self.config, parent = self)
 			mnt.umount(self.config.current_hash_id)
 		except mount.MountException as ex:
 			KMessageBox.error( self, QString.fromUtf8( str(ex) ) )
@@ -465,7 +465,7 @@
 			
 	def remount( self, new_profile_id, old_profile_id):
 		try:
-			mnt = mount.Mount(cfg = self.config, profile_id = old_profile_id)
+			mnt = mount.Mount(cfg = self.config, profile_id = old_profile_id, parent = self)
 			hash_id = mnt.remount(new_profile_id)
 		except mount.MountException as ex:
 			KMessageBox.error( self, QString.fromUtf8( str(ex) ) )

=== modified file 'kde4/debian_specific/control'
--- kde4/debian_specific/control	2013-01-09 21:02:50 +0000
+++ kde4/debian_specific/control	2013-03-07 23:23:23 +0000
@@ -7,7 +7,7 @@
 Architecture: all
 Homepage: http://backintime.le-web.org
 Depends: x11-utils, kdesudo, libnotify-bin, python-kde4 (>= 4.1), backintime-common (>= 1.0.21~), backintime-notify (>= 1.0.21~)
-Suggests: kompare
+Suggests: kompare, python-keyring-kwallet
 Conflicts: backintime-kde
 Replaces: backintime-kde
 Description: Simple backup system for KDE4 Desktop

=== added file 'kde4/messagebox.py'
--- kde4/messagebox.py	1970-01-01 00:00:00 +0000
+++ kde4/messagebox.py	2013-03-07 23:23:23 +0000
@@ -0,0 +1,49 @@
+#    Copyright (c) 2012-2013 Germar Reitze
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import sys
+from PyKDE4.kdecore import ki18n, KAboutData, KCmdLineArgs
+from PyKDE4.kdeui import KApplication, KPasswordDialog
+from PyQt4.QtCore import QString, QTimer, SIGNAL
+
+import app
+
+def ask_password_dialog(parent, config, title, prompt, timeout = None):
+    if parent is None:
+        kapp, kaboutData = app.create_kapplication( config )
+
+    dialog = KPasswordDialog()
+    
+    timer = QTimer()
+    if not timeout is None:
+        dialog.connect(timer, SIGNAL("timeout()"), dialog.close)
+        timer.setInterval(timeout * 1000)
+        timer.start()
+
+    dialog.setPrompt( QString.fromUtf8(prompt))
+    dialog.show()
+    KApplication.processEvents()
+
+    if parent is None:
+        kapp.exec_()
+    else:
+        dialog.exec_()
+
+    timer.stop()
+    password = dialog.password()
+    del(dialog)
+
+    return(password)

=== modified file 'kde4/settingsdialog.py'
--- kde4/settingsdialog.py	2013-03-04 21:16:20 +0000
+++ kde4/settingsdialog.py	2013-03-07 23:23:23 +0000
@@ -22,6 +22,8 @@
 import datetime
 import gettext
 import copy
+import subprocess
+import keyring
 
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -33,6 +35,7 @@
 import tools
 import kde4tools
 import mount
+import password
 
 
 _=gettext.gettext
@@ -150,6 +153,8 @@
 		vlayout.addLayout( hlayout1 )
 		hlayout2 = QHBoxLayout()
 		vlayout.addLayout( hlayout2 )
+		hlayout3 = QHBoxLayout()
+		vlayout.addLayout( hlayout3 )
 		
 		self.lbl_ssh_host = QLabel( QString.fromUtf8( _( 'Host:' ) ), self )
 		hlayout1.addWidget( self.lbl_ssh_host )
@@ -172,11 +177,21 @@
 		hlayout2.addWidget( self.txt_ssh_path )
 		
 		self.lbl_ssh_cipher = QLabel( QString.fromUtf8( _( 'Cipher:' ) ), self )
-		hlayout2.addWidget( self.lbl_ssh_cipher )
+		hlayout3.addWidget( self.lbl_ssh_cipher )
 		self.combo_ssh_cipher = KComboBox( self )
-		hlayout2.addWidget( self.combo_ssh_cipher )
+		hlayout3.addWidget( self.combo_ssh_cipher )
 		self.fill_combo( self.combo_ssh_cipher, self.config.SSH_CIPHERS )
 		
+		self.lbl_ssh_private_key_file = QLabel( QString.fromUtf8( _( 'Private Key:' ) ), self )
+		hlayout3.addWidget( self.lbl_ssh_private_key_file )
+		self.txt_ssh_private_key_file = KLineEdit( self )
+		self.txt_ssh_private_key_file.setReadOnly( True )
+		hlayout3.addWidget( self.txt_ssh_private_key_file )
+		
+		self.btn_ssh_private_key_file = KPushButton( KIcon( 'folder' ), '', self )
+		hlayout3.addWidget( self.btn_ssh_private_key_file )
+		QObject.connect( self.btn_ssh_private_key_file, SIGNAL('clicked()'), self.on_btn_ssh_private_key_file_clicked )
+		
 ##		#Dummy
 ##		group_box = QGroupBox( self )
 ##		self.mode_dummy = group_box
@@ -203,12 +218,36 @@
 ##		self.txt_dummy_user = KLineEdit( self )
 ##		hlayout.addWidget( self.txt_dummy_user )
 
+		#password
+		group_box = QGroupBox( self )
+		self.frame_password = group_box
+		group_box.setTitle( QString.fromUtf8( _( 'Password' ) ) )
+		layout.addWidget( group_box )
+
+		vlayout = QVBoxLayout( group_box )
+
+		self.txt_password = KLineEdit( self )
+		self.txt_password.setPasswordMode(True)
+		vlayout.addWidget( self.txt_password )
+
+		self.cb_password_save = QCheckBox( QString.fromUtf8( _( 'Save Password to Keyring' ) ), self )
+		QObject.connect( self.cb_password_save, SIGNAL('stateChanged(int)'), self.update_password_save )
+		vlayout.addWidget( self.cb_password_save )
+
+		self.cb_password_use_cache = QCheckBox( QString.fromUtf8( _( 'Cache Password for Cron (Security issue: root can read password)' ) ), self )
+		vlayout.addWidget( self.cb_password_use_cache )
+
+		#mode change
 		QObject.connect( self.combo_modes, SIGNAL('currentIndexChanged(int)'), self.on_combo_modes_changed )
 		self.on_combo_modes_changed()
 		
 		#host, user, profile id
-		hlayout = QHBoxLayout()
-		layout.addLayout( hlayout )
+		group_box = QGroupBox( self )
+		self.frame_advanced = group_box
+		group_box.setTitle( QString.fromUtf8( _( 'Advanced' ) ) )
+		layout.addWidget( group_box )
+		
+		hlayout = QHBoxLayout( group_box )
 		hlayout.addSpacing( 12 )
 
 		vlayout2 = QVBoxLayout()
@@ -620,6 +659,12 @@
 		self.lbl_profile.setEnabled( enabled )
 		self.txt_profile.setEnabled( enabled )
 
+	def update_password_save( self ):
+		enabled = self.cb_password_save.isChecked()
+		if enabled and tools.check_home_encrypt():
+			enabled = False
+		self.cb_password_use_cache.setEnabled( enabled )
+
 	def update_profiles( self ):
 		self.update_profile()
 		current_profile_id = self.config.get_current_profile()
@@ -657,12 +702,22 @@
 		self.txt_ssh_user.setText( QString.fromUtf8( self.config.get_ssh_user() ) )
 		self.txt_ssh_path.setText( QString.fromUtf8( self.config.get_snapshots_path_ssh() ) )
 		self.set_combo_value( self.combo_ssh_cipher, self.config.get_ssh_cipher(), type = 'str' )
+		self.txt_ssh_private_key_file.setText( QString.fromUtf8( self.config.get_ssh_private_key_file() ) )
 		
 ##		#dummy
 ##		self.txt_dummy_host.setText( QString.fromUtf8( self.config.get_dummy_host() ) )
 ##		self.txt_dummy_port.setText( QString.fromUtf8( self.config.get_dummy_port() ) )
 ##		self.txt_dummy_user.setText( QString.fromUtf8( self.config.get_dummy_user() ) )
 
+		#password
+		password = self.config.get_password( mode = self.mode, only_from_keyring = True )
+		if password is None:
+			password = ''
+		self.txt_password.setText( QString.fromUtf8( password ) )
+		self.cb_password_save.setChecked( self.config.get_password_save( mode = self.mode ) )
+		self.cb_password_use_cache.setChecked( self.config.get_password_use_cache( mode = self.mode ) )
+		self.update_password_save()
+
 		self.cb_auto_host_user_profile.setChecked( self.config.get_auto_host_user_profile() )
 		host, user, profile = self.config.get_host_user_profile()
 		self.txt_host.setText( QString.fromUtf8( host ) )
@@ -750,14 +805,25 @@
 		self.config.set_snapshots_mode( mode )
 		mount_kwargs = {}
 		
+		#password
+		password = str( self.txt_password.text().toUtf8() )
+		
 		#ssh
 		ssh_host = str( self.txt_ssh_host.text().toUtf8() )
 		ssh_port = str( self.txt_ssh_port.text().toUtf8() )
 		ssh_user = str( self.txt_ssh_user.text().toUtf8() )
 		ssh_path = str( self.txt_ssh_path.text().toUtf8() )
 		ssh_cipher = str( self.combo_ssh_cipher.itemData( self.combo_ssh_cipher.currentIndex() ).toString().toUtf8() )
+		ssh_private_key_file = str( self.txt_ssh_private_key_file.text().toUtf8() )
 		if mode == 'ssh':
-			mount_kwargs = { 'host': ssh_host, 'port': int(ssh_port), 'user': ssh_user, 'path': ssh_path, 'cipher': ssh_cipher }
+			mount_kwargs = {'host': ssh_host,
+							'port': int(ssh_port),
+							'user': ssh_user,
+							'path': ssh_path,
+							'cipher': ssh_cipher,
+							'private_key_file': ssh_private_key_file,
+							'password': password
+							}
 			
 ##		#dummy
 ##		dummy_host = str( self.txt_dummy_host.text().toUtf8() )
@@ -767,7 +833,11 @@
 ##			#values must have exactly the same Type (str, int or bool) 
 ##			#as they are set in config or you will run into false-positive
 ##			#HashCollision warnings
-##			mount_kwargs = { 'host': dummy_host, 'port': int(dummy_port), 'user': dummy_user }
+##			mount_kwargs = {'host': dummy_host,
+##							'port': int(dummy_port),
+##							'user': dummy_user,
+##							'password': password
+##							}
 			
 		if not self.config.SNAPSHOT_MODES[mode][0] is None:
 			#pre_mount_check
@@ -805,12 +875,34 @@
 		self.config.set_ssh_user(ssh_user)
 		self.config.set_snapshots_path_ssh(ssh_path)
 		self.config.set_ssh_cipher(ssh_cipher)
+		self.config.set_ssh_private_key_file(ssh_private_key_file)
 		
 ##		#save dummy
 ##		self.config.set_dummy_host(dummy_host)
 ##		self.config.set_dummy_port(dummy_port)
 ##		self.config.set_dummy_user(dummy_user)
 
+		#save password
+		if self.cb_password_save.isChecked():
+			if self.config.get_keyring_backend() == '':
+				self.config.set_keyring_backend('kwallet')
+			if self.config.get_keyring_backend() == 'gnomekeyring':
+				if keyring.backend.GnomeKeyring().supported() == 1:
+					keyring.set_keyring(keyring.backend.GnomeKeyring())
+				else:
+					self.config.set_keyring_backend('kwallet')
+			if self.config.get_keyring_backend() == 'kwallet':
+				if keyring.backend.KDEKWallet().supported() == 1:
+					keyring.set_keyring(keyring.backend.KDEKWallet())
+				else:
+					#in Kubuntu keyring.backend.KDEKWallet is included in python-keyring
+					#but Debian uses an extra package for this: python-keyring-kwallet
+					self.error_handler( _('Can\'t connect to KWallet to save password. On Debian you need to install:\n\'apt-get install python-keyring-kwallet\''))
+					return False
+		self.config.set_password_save(self.cb_password_save.isChecked(), mode = mode)
+		self.config.set_password_use_cache(self.cb_password_use_cache.isChecked(), mode = mode)
+		self.config.set_password(password, mode = mode)
+
 		#include list 
 		include_list = []
 		for index in xrange( self.list_include.topLevelItemCount() ):
@@ -992,6 +1084,15 @@
 			return False
 
 		self.config.save()
+
+		#start Password_Cache if not running
+		daemon = password.Password_Cache(self.config)
+		if not daemon.status():
+			try:
+				subprocess.check_call(['backintime', '--pw-cache', 'start'], stdout=open(os.devnull, 'w'))
+			except subprocess.CalledProcessError as e:
+				self.error_handler( _('start Password Cache failed: %s') % e.strerror)
+
 		return True
 
 	def on_btn_exclude_remove_clicked ( self ):
@@ -1085,6 +1186,17 @@
 				if not self.question_handler( _('Are you sure you want to change snapshots folder ?') ):
 					return
 			self.edit_snapshots_path.setText( QString.fromUtf8( self.config.prepare_path( path ) ) )
+
+	def on_btn_ssh_private_key_file_clicked( self ):
+		old_file = str( self.txt_ssh_private_key_file.text().toUtf8() )
+
+		if len(old_file) > 0:
+			start_dir = KUrl( self.txt_ssh_private_key_file.text() )
+		else:
+			start_dir = KUrl( self.config.get_ssh_private_key_folder() )
+		file = str( KFileDialog.getOpenFileName( start_dir, QString.fromUtf8(''), self, QString.fromUtf8( _( 'SSH private key' ) ) ).toUtf8() )
+		if len( file ) > 0 :
+			self.txt_ssh_private_key_file.setText( QString.fromUtf8( self.config.prepare_path( file ) ) )
 		
 	def on_combo_modes_changed(self, *params):
 		if len(params) == 0:
@@ -1099,6 +1211,10 @@
 				else:
 					getattr(self, 'mode_%s' % mode).hide()
 			self.mode = active_mode
+		if active_mode in self.config.SNAPSHOT_MODES_NEED_PASSWORD:
+			self.frame_password.show()
+		else:
+			self.frame_password.hide()
 		
 	def accept( self ):
 		if self.validate():

=== modified file 'makedeb.sh'
--- makedeb.sh	2012-10-27 14:42:44 +0000
+++ makedeb.sh	2013-03-07 23:23:23 +0000
@@ -21,6 +21,7 @@
 	echo "Installed-Size: `du -sk tmp | cut -f1`" >> tmp/DEBIAN/control
 	
 	cp $i/debian_specific/postrm tmp/DEBIAN/postrm
+	[ -e $i/debian_specific/conffiles ] && cp $i/debian_specific/conffiles tmp/DEBIAN/conffiles
 
 	dpkg --build tmp/ $PKGNAME-${PKGVER}_$PKGARCH.deb