#!/bin/env python

 # -*- coding: utf-8 -*-

 # ------------------------------------------------------------

 # opensecurity-launcher

 # 

 # launches an application inside a VM

 #

 # Autor: Oliver Maurhart, <oliver.maurhart@ait.ac.at>

 #

 # Copyright (C) 2013 AIT Austrian Institute of Technology

 # AIT Austrian Institute of Technology GmbH

 # Donau-City-Strasse 1 | 1220 Vienna | Austria

 # http://www.ait.ac.at

 #

 # 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 version 2.

 # 

 # 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.

 # ------------------------------------------------------------

 # ------------------------------------------------------------

 # imports

 import argparse

 import os

 import subprocess

 import sys

 from PyQt4 import QtCore

 from PyQt4 import QtGui

 # local

 from about import About

 from cygwin import Cygwin

 from environment import Environment

 import opensecurity_server

 # ------------------------------------------------------------

 # code

 class Chooser(QtGui.QDialog, object):

     """Ask the user what to launch."""

     def __init__(self, parent = None, flags = QtCore.Qt.WindowFlags(0)):

         super(Chooser, self).__init__(parent, flags)

         self.setWindowTitle('OpenSecuirty Launch Application')

         self.setup_ui()

         # known vms and applications

         self._apps, self_vms = [], []

         # positionate ourself central

         screen = QtGui.QDesktopWidget().screenGeometry()

         self.resize(self.geometry().width() * 1.25, self.geometry().height())

         size = self.geometry()

         self.move((screen.width() - size.width()) / 2, (screen.height() - size.height()) / 2)

         # refresh vm and command input

         self.refresh()

     def app_get(self):

         """The application of the user."""

         a = str(self._cbApplication.currentText())

         for app in self._apps:

             if a == app['name']:

                 return app['command']

         return a

     app = property(app_get)

     def clicked_about(self):

         """clicked the about button"""

         dlgAbout = About()

         dlgAbout.exec_()

     def clicked_cancel(self):

         """clicked the cancel button"""

         self.reject()

     def clicked_ok(self):

         """clicked the ok button"""

         self.accept()

     def refresh(self):

         """load the known vms and commands and adjust input fields"""

         self._apps = opensecurity_server.query_apps()

         self._vms = opensecurity_server.query_vms()

         # add the VMs we know

         self._cbApplication.clear()

         for app in self._apps:

             self._cbApplication.addItem(app['name'])

         # add the commands we know

         self._cbVM.clear()

         for vm in self._vms:

             self._cbVM.addItem(vm['name'])

     def setup_ui(self):

         """Create the widgets."""

         lyMain = QtGui.QVBoxLayout(self)

         lyMain.setContentsMargins(8, 8, 8, 8)

         # content area: left pixmap, right text

         lyContent = QtGui.QHBoxLayout()

         lyMain.addLayout(lyContent)

         # pixmap

         lbPix = QtGui.QLabel()

         lbPix.setPixmap(QtGui.QPixmapCache.find('opensecurity_icon_64'))

         lyContent.addWidget(lbPix, 0, QtCore.Qt.Alignment(QtCore.Qt.AlignTop + QtCore.Qt.AlignHCenter))

         lyContent.addSpacing(16)

         # launch ...

         lyLaunch = QtGui.QGridLayout()

         lyContent.addLayout(lyLaunch)

         lbTitle = QtGui.QLabel('Specify details for application to launch.')

         lyLaunch.addWidget(lbTitle, 0, 0, 1, 2)

         lbVM = QtGui.QLabel('&VM-ID:')

         lyLaunch.addWidget(lbVM, 1, 0)

         self._cbVM = QtGui.QComboBox()

         self._cbVM.setEditable(True)

         self._cbVM.setInsertPolicy(QtGui.QComboBox.InsertAlphabetically)

         lyLaunch.addWidget(self._cbVM, 1, 1)

         lbVM.setBuddy(self._cbVM)

         lbApplication = QtGui.QLabel('&Application:')

         lyLaunch.addWidget(lbApplication, 2, 0)

         self._cbApplication = QtGui.QComboBox()

         self._cbApplication.setEditable(True)

         self._cbApplication.setInsertPolicy(QtGui.QComboBox.InsertAlphabetically)

         lyLaunch.addWidget(self._cbApplication, 2, 1)

         lbApplication.setBuddy(self._cbApplication)

         lyLaunch.addWidget(QtGui.QWidget(), 3, 0, 1, 2)

         lyLaunch.setColumnStretch(1, 1)

         lyLaunch.setRowStretch(3, 1)

         lyMain.addStretch(1)

         # buttons

         lyButton = QtGui.QHBoxLayout()

         lyMain.addLayout(lyButton)

         lyButton.addStretch(1)

         btnOk = QtGui.QPushButton('&Ok', self)

         btnOk.setDefault(True)

         btnOk.setMinimumWidth(100)

         lyButton.addWidget(btnOk)

         btnCancel = QtGui.QPushButton('&Cancel', self)

         btnCancel.setMinimumWidth(100)

         lyButton.addWidget(btnCancel)

         btnAbout = QtGui.QPushButton('&About', self)

         btnAbout.setMinimumWidth(100)

         lyButton.addWidget(btnAbout)

         button_width = max(btnOk.width(), btnCancel.width(), btnAbout.width())

         btnOk.setMinimumWidth(button_width)

         btnCancel.setMinimumWidth(button_width)

         btnAbout.setMinimumWidth(button_width)

         # reduce to the max

         self.resize(lyMain.minimumSize())

         # connectors

         btnOk.clicked.connect(self.clicked_ok)

         btnCancel.clicked.connect(self.clicked_cancel)

         btnAbout.clicked.connect(self.clicked_about)

     def user_get(self):

         """The user of the vm of choice."""

         v = str(self._cbVM.currentText())

         for vm in self._vms:

             if v == vm['name']:

                 return vm['user']

         return v

     user = property(user_get)

     def vm_get(self):

         """The vm of choice."""

         v = str(self._cbVM.currentText())

         for vm in self._vms:

             if v == vm['name']:

                 return vm['ip']

         return v

     vm = property(vm_get)

 def ask_user():

     """ask the user for VM and app to start"""

     # launch Qt

     app = QtGui.QApplication(sys.argv)

     # prebuild the pixmap cache: fetch all jpg, png and jpeg images and load them

     image_path = os.path.join(Environment("OpenSecurity").data_path, '..', 'gfx')

     for file in os.listdir(image_path):

         if file.lower().rpartition('.')[2] in ('jpg', 'png', 'jpeg'):

             QtGui.QPixmapCache.insert(file.lower().rpartition('.')[0], QtGui.QPixmap(os.path.join(image_path, file)))

     # we should have now our application icon

     app.setWindowIcon(QtGui.QIcon(QtGui.QPixmapCache.find('opensecurity_icon_64')))

     # pop up the dialog

     dlg = Chooser()

     dlg.show()

     app.exec_()

     if dlg.result() == QtGui.QDialog.Accepted:

         return dlg.user, dlg.vm, dlg.app

     return '', '', ''

 def main():

     """entry point"""

     # parse command line

     parser = argparse.ArgumentParser(description = 'OpenSecurity Launcher: run application in VM')

     parser.add_argument('user', metavar='USER', help='USER on Virtual Machine', nargs='?', type=str, default='')

     parser.add_argument('ip', metavar='IP', help='IP of Virtual Machine', nargs='?', type=str, default='')

     parser.add_argument('command', metavar='COMMAND', help='Full path of command and arguments to start inside VM', nargs='?', type=str, default='')

     args = parser.parse_args()

     # we must have at least all or none set

     set_user = args.user != ''

     set_ip = args.ip != ''

     set_command = args.command != ''

     set_ALL = set_user and set_ip and set_command

     set_NONE = (not set_user) and (not set_ip) and (not set_command)

     if (not set_ALL) and (not set_NONE):

         sys.stderr.write("Please specify user, ip and command or none.\n")

         sys.stderr.write("Type '--help' for help.\n")

         sys.exit(1)

     # check if we need to ask the user

     if set_NONE:

         args.user, args.ip, args.command = ask_user()

     # still no IP? --> no chance, over and out!

     if args.ip == '':

         sys.exit(0)

     # ensure we have our X11 running

     Cygwin.start_X11()

     # the SSH command

     user_at_guest = args.user + '@' + args.ip

     ssh = 'DISPLAY=:0 /usr/bin/ssh -Y ' + user_at_guest + ' ' + args.command

     print(ssh)

     # off we go!

     Cygwin()(['/bin/bash', '--login', '-i', '-c', ssh], None, None, None)

 # start

 if __name__ == "__main__":

     main()