settings.py 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897
  1. #!/usr/bin/python2
  2. #
  3. # The Qubes OS Project, http://www.qubes-os.org
  4. #
  5. # Copyright (C) 2012 Agnieszka Kostrzewa <agnieszka.kostrzewa@gmail.com>
  6. # Copyright (C) 2012 Marek Marczykowski-Górecki
  7. # <marmarek@invisiblethingslab.com>
  8. # Copyright (C) 2017 Wojtek Porczyk <woju@invisiblethingslab.com>
  9. #
  10. # This program is free software; you can redistribute it and/or
  11. # modify it under the terms of the GNU General Public License
  12. # as published by the Free Software Foundation; either version 2
  13. # of the License, or (at your option) any later version.
  14. #
  15. # This program is distributed in the hope that it will be useful,
  16. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. # GNU General Public License for more details.
  19. #
  20. # You should have received a copy of the GNU General Public License
  21. # along with this program; if not, write to the Free Software
  22. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23. #
  24. #
  25. import collections
  26. import copy
  27. import os
  28. import os.path
  29. import subprocess
  30. import sys
  31. import threading
  32. import time
  33. import traceback
  34. import qubesadmin
  35. import qubesadmin.tools
  36. from . import utils
  37. from . import multiselectwidget
  38. from . import thread_monitor
  39. from .appmenu_select import AppmenuSelectManager
  40. from .backup_utils import get_path_for_vm
  41. from .firewall import *
  42. from .ui_settingsdlg import *
  43. from .bootfromdevice import main as bootfromdevice
  44. class VMSettingsWindow(Ui_SettingsDialog, QDialog):
  45. tabs_indices = collections.OrderedDict((
  46. ('basic', 0),
  47. ('advanced', 1),
  48. ('firewall', 2),
  49. ('devices', 3),
  50. ('applications', 4),
  51. ('services', 5),
  52. ))
  53. def __init__(self, vm, qapp, init_page="basic", parent=None):
  54. super(VMSettingsWindow, self).__init__(parent)
  55. self.vm = vm
  56. self.qapp = qapp
  57. try:
  58. self.source_vm = self.vm.template
  59. except AttributeError:
  60. self.source_vm = self.vm
  61. self.setupUi(self)
  62. self.setWindowTitle(self.tr("Settings: {vm}").format(vm=self.vm.name))
  63. if init_page in self.tabs_indices:
  64. idx = self.tabs_indices[init_page]
  65. assert (idx in range(self.tabWidget.count()))
  66. self.tabWidget.setCurrentIndex(idx)
  67. self.connect(self.buttonBox, SIGNAL("accepted()"), self.save_and_apply)
  68. self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
  69. self.tabWidget.currentChanged.connect(self.current_tab_changed)
  70. self.tabWidget.setTabEnabled(self.tabs_indices["firewall"],
  71. vm.netvm is not None and not vm.provides_network)
  72. ###### basic tab
  73. self.__init_basic_tab__()
  74. self.rename_vm_button.clicked.connect(self.rename_vm)
  75. ###### advanced tab
  76. self.__init_advanced_tab__()
  77. self.include_in_balancing.stateChanged.connect(self.include_in_balancing_state_changed)
  78. self.connect(self.init_mem, SIGNAL("editingFinished()"), self.check_mem_changes)
  79. self.connect(self.max_mem_size, SIGNAL("editingFinished()"), self.check_mem_changes)
  80. self.bootFromDeviceButton.clicked.connect(self.boot_from_cdrom_button_pressed)
  81. ###### firewall tab
  82. if self.tabWidget.isTabEnabled(self.tabs_indices['firewall']):
  83. model = QubesFirewallRulesModel()
  84. try:
  85. model.set_vm(vm)
  86. self.set_fw_model(model)
  87. self.firewallModifiedOutsidelabel.setVisible(False)
  88. except FirewallModifiedOutsideError as ex:
  89. self.disable_all_fw_conf()
  90. self.newRuleButton.clicked.connect(self.new_rule_button_pressed)
  91. self.editRuleButton.clicked.connect(self.edit_rule_button_pressed)
  92. self.deleteRuleButton.clicked.connect(self.delete_rule_button_pressed)
  93. self.policyDenyRadioButton.clicked.connect(self.policy_changed)
  94. self.policyAllowRadioButton.clicked.connect(self.policy_changed)
  95. ####### devices tab
  96. self.__init_devices_tab__()
  97. self.connect(self.dev_list, SIGNAL("selected_changed()"), self.devices_selection_changed)
  98. ####### services tab
  99. self.__init_services_tab__()
  100. self.add_srv_button.clicked.connect(self.__add_service__)
  101. self.remove_srv_button.clicked.connect(self.__remove_service__)
  102. ####### apps tab
  103. if self.tabWidget.isTabEnabled(self.tabs_indices["applications"]):
  104. self.app_list = multiselectwidget.MultiSelectWidget(self)
  105. self.apps_layout.addWidget(self.app_list)
  106. self.AppListManager = AppmenuSelectManager(self.vm, self.app_list)
  107. self.refresh_apps_button.clicked.connect(self.refresh_apps_button_pressed)
  108. def reject(self):
  109. self.done(0)
  110. #needed not to close the dialog before applying changes
  111. def accept(self):
  112. pass
  113. def save_and_apply(self):
  114. t_monitor = thread_monitor.ThreadMonitor()
  115. thread = threading.Thread(target=self.__save_changes__, args=(t_monitor,))
  116. thread.daemon = True
  117. thread.start()
  118. progress = QProgressDialog(
  119. self.tr("Applying settings to <b>{0}</b>...").format(self.vm.name), "", 0, 0)
  120. progress.setCancelButton(None)
  121. progress.setModal(True)
  122. progress.show()
  123. while not t_monitor.is_finished():
  124. self.qapp.processEvents()
  125. time.sleep (0.1)
  126. progress.hide()
  127. if not t_monitor.success:
  128. QMessageBox.warning(None,
  129. self.tr("Error while changing settings for {0}!").format(self.vm.name),
  130. self.tr("ERROR: {0}").format(t_monitor.error_msg))
  131. self.done(0)
  132. def __save_changes__(self, t_monitor):
  133. self.anything_changed = False
  134. ret = []
  135. try:
  136. ret_tmp = self.__apply_basic_tab__()
  137. if len(ret_tmp) > 0:
  138. ret += ["Basic tab:"] + ret_tmp
  139. ret_tmp = self.__apply_advanced_tab__()
  140. if len(ret_tmp) > 0:
  141. ret += ["Advanced tab:"] + ret_tmp
  142. ret_tmp = self.__apply_devices_tab__()
  143. if len(ret_tmp) > 0:
  144. ret += ["Devices tab:"] + ret_tmp
  145. ret_tmp = self.__apply_services_tab__()
  146. if len(ret_tmp) > 0:
  147. ret += ["Sevices tab:"] + ret_tmp
  148. except Exception as ex:
  149. ret.append(self.tr('Error while saving changes: ') + str(ex))
  150. try:
  151. if self.policyAllowRadioButton.isEnabled():
  152. self.fw_model.apply_rules(self.policyAllowRadioButton.isChecked(),
  153. self.tempFullAccess.isChecked(),
  154. self.tempFullAccessTime.value())
  155. if self.fw_model.fw_changed:
  156. # might modified vm.services
  157. self.anything_changed = True
  158. except Exception as ex:
  159. ret += [self.tr("Firewall tab:"), str(ex)]
  160. try:
  161. if self.tabWidget.isTabEnabled(self.tabs_indices["applications"]):
  162. self.AppListManager.save_appmenu_select_changes()
  163. except Exception as ex:
  164. ret += [self.tr("Applications tab:"), str(ex)]
  165. if len(ret) > 0 :
  166. t_monitor.set_error_msg('\n'.join(ret))
  167. utils.debug('\n'.join(ret))
  168. t_monitor.set_finished()
  169. def current_tab_changed(self, idx):
  170. if idx == self.tabs_indices["firewall"]:
  171. netvm = self.vm.netvm
  172. if netvm is not None and \
  173. not netvm.features.check_with_template('qubes-firewall', False):
  174. QMessageBox.warning(None,
  175. self.tr("VM configuration problem!"),
  176. self.tr("The '{vm}' AppVM is network connected to "
  177. "'{netvm}', which does not support firewall!<br/>"
  178. "You may edit the '{vm}' VM firewall rules, but these "
  179. "will not take any effect until you connect it to "
  180. "a working Firewall VM.").format(
  181. vm=self.vm.name, netvm=netvm.name))
  182. ######### basic tab
  183. # TODO LISTENERS
  184. # - vm start/shutdown -> setEnabled on fields: template labels
  185. # - vm create/delete -> choices lists, whole window deactiv (if self.vm)
  186. # - property-set -> individual fields
  187. # TODO INTERACTIONS
  188. # netvm -> networking_groupbox
  189. # hvm -> include_in_balancing
  190. # TODO REMOVE
  191. # other_groupbox
  192. def __init_basic_tab__(self):
  193. self.vmname.setText(self.vm.name)
  194. self.vmname.setValidator(QRegExpValidator(QRegExp("[a-zA-Z0-9-]*", Qt.CaseInsensitive), None))
  195. self.vmname.setEnabled(False)
  196. self.rename_vm_button.setEnabled(not self.vm.is_running())
  197. if self.vm.qid == 0:
  198. self.vmlabel.setVisible(False)
  199. else:
  200. self.label_list, self.label_idx = utils.prepare_label_choice(
  201. self.vmlabel,
  202. self.vm, 'label',
  203. None,
  204. allow_default=False
  205. )
  206. self.vmlabel.setVisible(True)
  207. self.vmlabel.setEnabled(not self.vm.is_running())
  208. if isinstance(self.vm, qubesadmin.vm.AppVM):
  209. self.template_list, self.template_idx = utils.prepare_vm_choice(
  210. self.template_name,
  211. self.vm, 'template',
  212. self.vm.app.default_template,
  213. (lambda vm: isinstance(vm, qubesadmin.vm.TemplateVM)),
  214. allow_default=True, allow_none=False)
  215. else:
  216. self.template_name.setEnabled(False)
  217. self.template_idx = -1
  218. self.netvm_list, self.netvm_idx = utils.prepare_vm_choice(
  219. self.netVM,
  220. self.vm, 'netvm',
  221. self.vm.app.default_netvm,
  222. (lambda vm: vm.provides_network),
  223. allow_default=True, allow_none=True)
  224. self.include_in_backups.setChecked(self.vm.include_in_backups)
  225. try:
  226. self.run_in_debug_mode.setChecked(self.vm.debug)
  227. self.run_in_debug_mode.setVisible(True)
  228. except AttributeError:
  229. self.run_in_debug_mode.setVisible(False)
  230. try:
  231. self.autostart_vm.setChecked(self.vm.autostart)
  232. self.autostart_vm.setVisible(True)
  233. except AttributeError:
  234. self.autostart_vm.setVisible(False)
  235. #type
  236. self.type_label.setText(type(self.vm).__name__)
  237. #installed by rpm
  238. self.rpm_label.setText('Yes' if self.vm.installed_by_rpm else 'No')
  239. #networking info
  240. if self.vm.netvm:
  241. self.networking_groupbox.setEnabled(True)
  242. self.ip_label.setText(self.vm.ip or "none")
  243. self.netmask_label.setText(self.vm.visible_netmask or "none")
  244. self.gateway_label.setText(self.vm.visible_gateway or "none")
  245. else:
  246. self.networking_groupbox.setEnabled(False)
  247. #max priv storage
  248. self.priv_img_size = self.vm.volumes['private'].size // 1024**2
  249. self.max_priv_storage.setMinimum(self.priv_img_size)
  250. self.max_priv_storage.setValue(self.priv_img_size)
  251. self.root_img_size = self.vm.volumes['root'].size // 1024**2
  252. self.root_resize.setValue(self.root_img_size)
  253. self.root_resize.setMinimum(self.root_img_size)
  254. self.root_resize.setEnabled(self.vm.volumes['root'].save_on_stop)
  255. self.root_resize_label.setEnabled(self.root_resize.isEnabled())
  256. def __apply_basic_tab__(self):
  257. msg = []
  258. #vm label changed
  259. try:
  260. if self.vmlabel.isVisible():
  261. if self.vmlabel.currentIndex() != self.label_idx:
  262. label = self.label_list[self.vmlabel.currentIndex()]
  263. self.vm.label = label
  264. self.anything_changed = True
  265. except Exception as ex:
  266. msg.append(str(ex))
  267. #vm template changed
  268. try:
  269. if self.template_name.currentIndex() != self.template_idx:
  270. self.vm.template = \
  271. self.template_list[self.template_name.currentIndex()]
  272. self.anything_changed = True
  273. except Exception as ex:
  274. msg.append(str(ex))
  275. #vm netvm changed
  276. try:
  277. if self.netVM.currentIndex() != self.netvm_idx:
  278. self.vm.netvm = self.netvm_list[self.netVM.currentIndex()]
  279. self.anything_changed = True
  280. except Exception as ex:
  281. msg.append(str(ex))
  282. #include in backups
  283. try:
  284. if self.vm.include_in_backups != self.include_in_backups.isChecked():
  285. self.vm.include_in_backups = self.include_in_backups.isChecked()
  286. self.anything_changed = True
  287. except Exception as ex:
  288. msg.append(str(ex))
  289. #run_in_debug_mode
  290. try:
  291. if self.run_in_debug_mode.isVisible():
  292. if self.vm.debug != self.run_in_debug_mode.isChecked():
  293. self.vm.debug = self.run_in_debug_mode.isChecked()
  294. self.anything_changed = True
  295. except Exception as ex:
  296. msg.append(str(ex))
  297. #autostart_vm
  298. try:
  299. if self.autostart_vm.isVisible():
  300. if self.vm.autostart != self.autostart_vm.isChecked():
  301. self.vm.autostart = self.autostart_vm.isChecked()
  302. self.anything_changed = True
  303. except Exception as ex:
  304. msg.append(str(ex))
  305. #max priv storage
  306. priv_size = self.max_priv_storage.value()
  307. if self.priv_img_size != priv_size:
  308. try:
  309. self.vm.volumes['private'].resize(priv_size * 1024**2)
  310. self.anything_changed = True
  311. except Exception as ex:
  312. msg.append(str(ex))
  313. #max sys storage
  314. sys_size = self.root_resize.value()
  315. if self.root_img_size != sys_size:
  316. try:
  317. self.vm.volumes['root'].resize(priv_size * 1024**2)
  318. self.anything_changed = True
  319. except Exception as ex:
  320. msg.append(str(ex))
  321. return msg
  322. def check_mem_changes(self):
  323. if self.max_mem_size.value() < self.init_mem.value():
  324. QMessageBox.warning(None,
  325. self.tr("Warning!"),
  326. self.tr("Max memory can not be less than initial memory.<br>"
  327. "Setting max memory to equal initial memory."))
  328. self.max_mem_size.setValue(self.init_mem.value())
  329. # Linux specific limit: init memory must not be below max_mem_size/10.79 in order to allow scaling up to max_mem_size (or else "add_memory() failed: -17" problem)
  330. if self.init_mem.value() * 10 < self.max_mem_size.value():
  331. QMessageBox.warning(None,
  332. self.tr("Warning!"),
  333. self.tr("Initial memory can not be less than one tenth "
  334. "Max memory.<br>Setting initial memory to the minimum "
  335. "allowed value."))
  336. self.init_mem.setValue(self.max_mem_size.value() / 10)
  337. def _rename_vm(self, t_monitor, name):
  338. try:
  339. self.vm.app.clone_vm(self.vm, name)
  340. del self.vm.app.domains[self.vm.name]
  341. except Exception as ex:
  342. t_monitor.set_error_msg(str(ex))
  343. t_monitor.set_finished()
  344. def rename_vm(self):
  345. new_vm_name, ok = QInputDialog.getText(self, self.tr('Rename VM'), self.tr('New name: (WARNING: all other changes will be discarded)'))
  346. if ok:
  347. t_monitor = thread_monitor.ThreadMonitor()
  348. thread = threading.Thread(target=self._rename_vm, args=(t_monitor, new_vm_name,))
  349. thread.daemon = True
  350. thread.start()
  351. while not t_monitor.is_finished():
  352. self.qapp.processEvents()
  353. time.sleep (0.1)
  354. if not t_monitor.success:
  355. QMessageBox.warning(None,
  356. self.tr("Error renaming the VM!"),
  357. self.tr("ERROR: {}").format(
  358. t_monitor.error_msg))
  359. self.done(0)
  360. ######### advanced tab
  361. def __init_advanced_tab__(self):
  362. #mem/cpu
  363. # qubes_memory = QubesHost().memory_total/1024
  364. self.init_mem.setValue(int(self.vm.memory))
  365. # self.init_mem.setMaximum(qubes_memory)
  366. self.max_mem_size.setValue(int(self.vm.maxmem))
  367. # self.max_mem_size.setMaximum(qubes_memory)
  368. self.vcpus.setMinimum(1)
  369. # self.vcpus.setMaximum(QubesHost().no_cpus)
  370. self.vcpus.setValue(int(self.vm.vcpus))
  371. self.include_in_balancing.setEnabled(True)
  372. self.include_in_balancing.setChecked(
  373. self.vm.features.get('services.meminfo-writer', True))
  374. self.max_mem_size.setEnabled(self.include_in_balancing.isChecked())
  375. #in case VM is HVM
  376. if hasattr(self.vm, "kernel"):
  377. self.kernel_groupbox.setVisible(True)
  378. self.kernel_list, self.kernel_idx = utils.prepare_kernel_choice(
  379. self.kernel, self.vm, 'kernel',
  380. self.vm.app.default_kernel,
  381. allow_default=True, allow_none=True)
  382. else:
  383. self.kernel_groupbox.setVisible(False)
  384. self.other_groupbox.setVisible(False)
  385. if not hasattr(self.vm, 'default_dispvm'):
  386. self.other_groupbox.setVisible(False)
  387. else:
  388. self.other_groupbox.setVisible(True)
  389. self.default_dispvm_list, self.default_dispvm_idx = \
  390. utils.prepare_vm_choice(
  391. self.default_dispvm,
  392. self.vm, 'default_dispvm',
  393. self.vm.app.default_dispvm,
  394. (lambda vm: isinstance(vm, qubesadmin.vm.DispVM)),
  395. allow_default=True, allow_none=True)
  396. def __apply_advanced_tab__(self):
  397. msg = []
  398. #mem/cpu
  399. try:
  400. if self.init_mem.value() != int(self.vm.memory):
  401. self.vm.memory = self.init_mem.value()
  402. self.anything_changed = True
  403. if self.max_mem_size.value() != int(self.vm.maxmem):
  404. self.vm.maxmem = self.max_mem_size.value()
  405. self.anything_changed = True
  406. if self.vcpus.value() != int(self.vm.vcpus):
  407. self.vm.vcpus = self.vcpus.value()
  408. self.anything_changed = True
  409. except Exception as ex:
  410. msg.append(str(ex))
  411. #include_in_memory_balancing applied in services tab
  412. #in case VM is not Linux
  413. if hasattr(self.vm, "kernel") and self.kernel_groupbox.isVisible():
  414. try:
  415. if self.kernel.currentIndex() != self.kernel_idx:
  416. new_kernel = str(self.kernel.currentText())
  417. new_kernel = new_kernel.split(' ')[0]
  418. uses_default_kernel = False
  419. if new_kernel == "default":
  420. kernel = self.app.get_default_kernel()
  421. uses_default_kernel = True
  422. elif new_kernel == "none":
  423. kernel = None
  424. else:
  425. kernel = new_kernel
  426. self.vm.kernel = kernel
  427. # Set self.vm.uses_default_kernel after self.vm.kernel to ensure that
  428. # the correct value persists after QubesVm.kernel resets self.vm.uses_default_kernel
  429. # to False.
  430. self.vm.uses_default_kernel = uses_default_kernel
  431. self.anything_changed = True
  432. except Exception as ex:
  433. msg.append(str(ex))
  434. #vm default_dispvm changed
  435. try:
  436. if self.default_dispvm.currentIndex() != self.default_dispvm_idx:
  437. self.vm.default_dispvm = \
  438. self.default_dispvm_list[self.default_dispvm.currentIndex()]
  439. self.anything_changed = True
  440. except Exception as ex:
  441. msg.append(str(ex))
  442. return msg
  443. def boot_from_cdrom_button_pressed(self):
  444. self.save_and_apply()
  445. subprocess.check_call(['qubes-vm-boot-from-device', self.vm.name])
  446. ######## devices tab
  447. def __init_devices_tab__(self):
  448. self.dev_list = multiselectwidget.MultiSelectWidget(self)
  449. self.dev_list.add_all_button.setVisible(False)
  450. self.devices_layout.addWidget(self.dev_list)
  451. devs = []
  452. lspci = subprocess.check_output(['/usr/sbin/lspci']).decode()
  453. for dev in lspci.splitlines():
  454. devs.append((dev.rstrip(), dev.split(' ')[0]))
  455. class DevListWidgetItem(QListWidgetItem):
  456. def __init__(self, name, ident, parent = None):
  457. super(DevListWidgetItem, self).__init__(name, parent)
  458. self.ident = ident
  459. self.Type
  460. persistent = [ass.ident.replace('_', ':')
  461. for ass in self.vm.devices['pci'].persistent()]
  462. for name, ident in devs:
  463. if ident in persistent:
  464. self.dev_list.selected_list.addItem(
  465. DevListWidgetItem(name, ident))
  466. else:
  467. self.dev_list.available_list.addItem(
  468. DevListWidgetItem(name, ident))
  469. if self.dev_list.selected_list.count() > 0 and self.include_in_balancing.isChecked():
  470. self.dmm_warning_adv.show()
  471. self.dmm_warning_dev.show()
  472. else:
  473. self.dmm_warning_adv.hide()
  474. self.dmm_warning_dev.hide()
  475. if self.vm.is_running():
  476. self.dev_list.setEnabled(False)
  477. self.turn_off_vm_to_modify_devs.setVisible(True)
  478. else:
  479. self.dev_list.setEnabled(True)
  480. self.turn_off_vm_to_modify_devs.setVisible(False)
  481. def __apply_devices_tab__(self):
  482. msg = []
  483. try:
  484. old = [ass.ident.replace('_', ':')
  485. for ass in self.vm.devices['pci'].persistent()]
  486. new = [self.dev_list.selected_list.item(i).ident
  487. for i in range(self.dev_list.selected_list.count())]
  488. for ident in new:
  489. if ident not in old:
  490. ass = qubesadmin.devices.DeviceAssignment(
  491. self.vm.app.domains['dom0'],
  492. ident.replace(':', '_'),
  493. persistent=True)
  494. self.vm.devices['pci'].attach(ass)
  495. for ass in self.vm.devices['pci'].assignments(persistent=True):
  496. if ass.ident.replace('_', ':') not in new:
  497. self.vm.devices['pci'].detach(ass)
  498. self.anything_changed = True
  499. except Exception as ex:
  500. if utils.is_debug():
  501. traceback.print_exc()
  502. msg.append(str(ex))
  503. return msg
  504. def include_in_balancing_state_changed(self, state):
  505. for r in range (self.services_list.count()):
  506. item = self.services_list.item(r)
  507. if str(item.text()) == 'meminfo-writer':
  508. item.setCheckState(state)
  509. break
  510. if self.dev_list.selected_list.count() > 0:
  511. if state == QtCore.Qt.Checked:
  512. self.dmm_warning_adv.show()
  513. self.dmm_warning_dev.show()
  514. else:
  515. self.dmm_warning_adv.hide()
  516. self.dmm_warning_dev.hide()
  517. self.max_mem_size.setEnabled(self.include_in_balancing.isChecked())
  518. def devices_selection_changed(self):
  519. if self.include_in_balancing.isChecked():
  520. if self.dev_list.selected_list.count() > 0 :
  521. self.dmm_warning_adv.show()
  522. self.dmm_warning_dev.show()
  523. else:
  524. self.dmm_warning_adv.hide()
  525. self.dmm_warning_dev.hide()
  526. ######## applications tab
  527. def refresh_apps_in_vm(self, t_monitor):
  528. try:
  529. target_vm = self.vm.template
  530. except AttributeError:
  531. target_vm = self.vm
  532. if not target_vm.is_running():
  533. not_running = True
  534. target_vm.start()
  535. else:
  536. not_running = False
  537. subprocess.check_call(['qvm-sync-appmenus', target_vm.name])
  538. if not_running:
  539. target_vm.shutdown()
  540. t_monitor.set_finished()
  541. def refresh_apps_button_pressed(self):
  542. self.refresh_apps_button.setEnabled(False)
  543. self.refresh_apps_button.setText(self.tr('Refresh in progress...'))
  544. t_monitor = thread_monitor.ThreadMonitor()
  545. thread = threading.Thread(target=self.refresh_apps_in_vm, args=(t_monitor,))
  546. thread.daemon = True
  547. thread.start()
  548. while not t_monitor.is_finished():
  549. self.qapp.processEvents()
  550. time.sleep (0.1)
  551. self.AppListManager = AppmenuSelectManager(self.vm, self.app_list)
  552. self.refresh_apps_button.setEnabled(True)
  553. self.refresh_apps_button.setText(self.tr('Refresh Applications'))
  554. ######## services tab
  555. def __init_services_tab__(self):
  556. self.new_srv_dict = {}
  557. for feature in self.vm.features:
  558. if not feature.startswith('service.'):
  559. continue
  560. service = feature[len('service.'):]
  561. item = QListWidgetItem(service)
  562. item.setCheckState(QtCore.Qt.Checked
  563. if self.vm.features[feature] else QtCore.Qt.Unchecked)
  564. self.services_list.addItem(item)
  565. self.new_srv_dict[service] = self.vm.features[feature]
  566. self.connect(self.services_list, SIGNAL("itemClicked(QListWidgetItem *)"), self.services_item_clicked)
  567. def __add_service__(self):
  568. srv = str(self.service_line_edit.text()).strip()
  569. if srv != "":
  570. if srv in self.new_srv_dict:
  571. QMessageBox.information(None, '',
  572. self.tr('Service already on the list!'))
  573. else:
  574. item = QListWidgetItem(srv)
  575. item.setCheckState(QtCore.Qt.Checked)
  576. self.services_list.addItem(item)
  577. self.new_srv_dict[srv] = True
  578. def __remove_service__(self):
  579. item = self.services_list.currentItem()
  580. if not item:
  581. return
  582. if str(item.text()) == 'meminfo-writer':
  583. QMessageBox.information(None,
  584. self.tr('Service can not be removed'),
  585. self.tr('Service meminfo-writer can not be removed from the list.'))
  586. return
  587. row = self.services_list.currentRow()
  588. item = self.services_list.takeItem(row)
  589. del self.new_srv_dict[str(item.text())]
  590. def services_item_clicked(self, item):
  591. if str(item.text()) == 'meminfo-writer':
  592. if item.checkState() == QtCore.Qt.Checked:
  593. if not self.include_in_balancing.isChecked():
  594. self.include_in_balancing.setChecked(True)
  595. elif item.checkState() == QtCore.Qt.Unchecked:
  596. if self.include_in_balancing.isChecked():
  597. self.include_in_balancing.setChecked(False)
  598. def __apply_services_tab__(self):
  599. msg = []
  600. try:
  601. for r in range(self.services_list.count()):
  602. item = self.services_list.item(r)
  603. self.new_srv_dict[str(item.text())] = (item.checkState() == QtCore.Qt.Checked)
  604. balancing_was_checked = self.vm.features.get('service.meminfo-writer', True)
  605. balancing_is_checked = self.include_in_balancing.isChecked()
  606. meminfo_writer_checked = self.new_srv_dict.get('meminfo-writer', True)
  607. if balancing_is_checked != meminfo_writer_checked:
  608. if balancing_is_checked != balancing_was_checked:
  609. self.new_srv_dict['meminfo-writer'] = balancing_is_checked
  610. for service, v in self.new_srv_dict.items():
  611. feature = 'service.' + service
  612. if v != self.vm.features.get(feature, object()):
  613. self.vm.features[feature] = v
  614. self.anything_changed = True
  615. for feature in self.vm.features:
  616. if not feature.startswith('service.'):
  617. continue
  618. service = feature[len('service.'):]
  619. if service not in self.new_srv_dict:
  620. del self.vm.features[feature]
  621. except Exception as ex:
  622. msg.append(str(ex))
  623. return msg
  624. ######### firewall tab related
  625. def set_fw_model(self, model):
  626. self.fw_model = model
  627. self.rulesTreeView.setModel(model)
  628. self.rulesTreeView.header().setResizeMode(QHeaderView.ResizeToContents)
  629. self.rulesTreeView.header().setResizeMode(0, QHeaderView.Stretch)
  630. self.set_allow(model.allow)
  631. if model.tempFullAccessExpireTime:
  632. self.tempFullAccess.setChecked(True)
  633. self.tempFullAccessTime.setValue(
  634. (model.tempFullAccessExpireTime -
  635. int(datetime.datetime.now().strftime("%s")))/60)
  636. def disable_all_fw_conf(self):
  637. self.firewallModifiedOutsidelabel.setVisible(True)
  638. self.policyAllowRadioButton.setEnabled(False)
  639. self.policyDenyRadioButton.setEnabled(False)
  640. self.rulesTreeView.setEnabled(False)
  641. self.newRuleButton.setEnabled(False)
  642. self.editRuleButton.setEnabled(False)
  643. self.deleteRuleButton.setEnabled(False)
  644. self.firewalRulesLabel.setEnabled(False)
  645. self.tempFullAccessWidget.setEnabled(False)
  646. def set_allow(self, allow):
  647. self.policyAllowRadioButton.setChecked(allow)
  648. self.policyDenyRadioButton.setChecked(not allow)
  649. self.policy_changed(allow)
  650. def policy_changed(self, checked):
  651. self.rulesTreeView.setEnabled(self.policyDenyRadioButton.isChecked())
  652. self.newRuleButton.setEnabled(self.policyDenyRadioButton.isChecked())
  653. self.editRuleButton.setEnabled(self.policyDenyRadioButton.isChecked())
  654. self.deleteRuleButton.setEnabled(self.policyDenyRadioButton.isChecked())
  655. self.firewalRulesLabel.setEnabled(
  656. self.policyDenyRadioButton.isChecked())
  657. self.tempFullAccessWidget.setEnabled(
  658. self.policyDenyRadioButton.isChecked())
  659. def new_rule_button_pressed(self):
  660. dialog = NewFwRuleDlg()
  661. self.fw_model.run_rule_dialog(dialog)
  662. def edit_rule_button_pressed(self):
  663. selected = self.rulesTreeView.selectedIndexes()
  664. if len(selected) > 0:
  665. dialog = NewFwRuleDlg()
  666. dialog.set_ok_enabled(True)
  667. row = self.rulesTreeView.selectedIndexes().pop().row()
  668. self.fw_model.populate_edit_dialog(dialog, row)
  669. self.fw_model.run_rule_dialog(dialog, row)
  670. def delete_rule_button_pressed(self):
  671. for i in set([index.row() for index
  672. in self.rulesTreeView.selectedIndexes()]):
  673. self.fw_model.removeChild(i)
  674. # Bases on the original code by:
  675. # Copyright (c) 2002-2007 Pascal Varet <p.varet@gmail.com>
  676. def handle_exception(exc_type, exc_value, exc_traceback):
  677. filename, line, dummy, dummy = traceback.extract_tb(exc_traceback).pop()
  678. filename = os.path.basename(filename)
  679. error = "%s: %s" % (exc_type.__name__, exc_value)
  680. strace = ""
  681. stacktrace = traceback.extract_tb(exc_traceback)
  682. while len(stacktrace) > 0:
  683. (filename, line, func, txt) = stacktrace.pop()
  684. strace += "----\n"
  685. strace += "line: %s\n" %txt
  686. strace += "func: %s\n" %func
  687. strace += "line no.: %d\n" %line
  688. strace += "file: %s\n" %filename
  689. msg_box = QMessageBox()
  690. msg_box.setDetailedText(strace)
  691. msg_box.setIcon(QMessageBox.Critical)
  692. msg_box.setWindowTitle("Houston, we have a problem...")
  693. msg_box.setText("Whoops. A critical error has occured. This is most likely a bug "
  694. "in Qubes Manager.<br><br>"
  695. "<b><i>%s</i></b>" % error +
  696. "<br/>at line <b>%d</b><br/>of file %s.<br/><br/>"
  697. % ( line, filename ))
  698. msg_box.exec_()
  699. parser = qubesadmin.tools.QubesArgumentParser(vmname_nargs=1)
  700. parser.add_argument('--tab', metavar='TAB',
  701. action='store',
  702. choices=VMSettingsWindow.tabs_indices.keys())
  703. parser.set_defaults(
  704. tab='basic',
  705. )
  706. def main(args=None):
  707. global settings_window
  708. args = parser.parse_args(args)
  709. vm = args.domains.pop()
  710. qapp = QApplication(sys.argv)
  711. qapp.setOrganizationName('Invisible Things Lab')
  712. qapp.setOrganizationDomain("https://www.qubes-os.org/")
  713. qapp.setApplicationName("Qubes VM Settings")
  714. if not utils.is_debug():
  715. sys.excepthook = handle_exception
  716. settings_window = VMSettingsWindow(vm, qapp, args.tab)
  717. settings_window.show()
  718. qapp.exec_()
  719. qapp.exit()
  720. if __name__ == "__main__":
  721. main()
  722. # vim:sw=4:et: