#!/bin/env python

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

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

# cygwin command

# 

# executes a cygwin command inside the opensecurity project

#

# Autor: Mihai Bartha, <mihai.bartha@ait.ac.at>

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

import subprocess

import sys

import _winreg

from subprocess import Popen, PIPE, call, STARTUPINFO, _subprocess

import threading

# local

from environment import Environment

from opensecurity_util import logger, setupLogger, OpenSecurityException

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

# code

def once(theClass):

    """get the path to our local cygwin installment"""

    home_drive = os.path.expandvars("%HOMEDRIVE%") + os.sep

    path_hint = [ 

        os.path.abspath(os.path.join(Environment('OpenSecurity').prefix_path, '..', 'cygwin')), 

        os.path.abspath(os.path.join(Environment('OpenSecurity').prefix_path, '..', 'cygwin64')), 

        os.path.abspath(os.path.join(home_drive, 'cygwin')),

        os.path.abspath(os.path.join(home_drive, 'cygwin64'))

    ]

    path_valid = [ p for p in path_hint if os.path.exists(p) ]

    theClass.cygwin_root = path_valid[0]

    theClass.cygwin_bin = os.path.join(theClass.cygwin_root, 'bin') + os.path.sep

    theClass.cygwin_bash = os.path.join(theClass.cygwin_bin, 'bash.exe')

    theClass.cygwin_ssh = os.path.join(theClass.cygwin_bin, 'ssh.exe')

    theClass.cygwin_x11 = os.path.join(theClass.cygwin_bin, 'XWin.exe')

    theClass.win_cmd = os.environ.get("COMSPEC", "cmd.exe") 

    """get the path to the VirtualBox installation on this system"""

    theClass.vbox_root = theClass.getRegEntry('SOFTWARE\Oracle\VirtualBox', 'InstallDir')[0]

    theClass.vbox_man = os.path.join(theClass.vbox_root, 'VBoxManage.exe')

    return theClass

@once

class Cygwin(object):

    cygwin_root = ''

    cygwin_bin = ''

    cygwin_bash = ''

    cygwin_ssh = ''

    cygwin_x11 = ''

    vbox_root = ''

    vbox_man = ''

    win_cmd = ''

    """Some nifty methods working with Cygwin"""

    def __call__(self, command, arguments, wait_return=True, window = False):

        """make an instance of this object act as a function"""

        return self.execute(command, arguments, wait_return, window)

    @staticmethod

    def getRegEntry(key, value):

        try:

            k = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, key)

            value = _winreg.QueryValueEx(k, value)

            _winreg.CloseKey(k)

            return value

        except:

            pass

    @staticmethod

    def root():

        return Cygwin.cygwin_root

    @staticmethod

    def bin():

        return Cygwin.cygwin_bin

    @staticmethod

    def bash():

        return Cygwin.cygwin_bash

    @staticmethod    

    def ssh():

        return Cygwin.cygwin_ssh

    @staticmethod    

    def x11():

        return Cygwin.cygwin_x11

    @staticmethod

    def vboxman():

        return Cygwin.vbox_man

    @staticmethod

    def cmd():

        return Cygwin.win_cmd

    executeLock = threading.Lock()

    #executes command on host system

    @staticmethod

    def execute(program, arguments, wait_return=True, window = False):

        _startupinfo = STARTUPINFO()

        if not window:

            _startupinfo.dwFlags |= _subprocess.STARTF_USESHOWWINDOW

            _startupinfo.wShowWindow = _subprocess.SW_HIDE

            #logger.debug('trying to launch: ' + program + ' ' + ''.join(arguments))

        res_stderr = None

        try:

            process = Popen(executable=program, args=' ' + arguments, startupinfo = _startupinfo, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell = False)

            logger.debug('Launched: ' + program + ' ' + ''.join(arguments))

            if not wait_return:

                return [0, 'working in background', '']

            result = process.wait()

            res_stdout = process.stdout.read();

            res_stderr = process.stderr.read();

        except Exception as ex:

            res_stderr.join(ex.args)

            result = 1 

        return result, res_stdout, res_stderr

    @staticmethod

    def vboxExecute(command, wait_return=True, window = False, bash_opts=''):

        retry = 0

        result = None

        while retry < 3:

            if Cygwin.executeLock.acquire(True):

                result = Cygwin.execute(Cygwin.vbox_man, command, wait_return, window)

                Cygwin.executeLock.release()

                if result[0] == 0:

                    return result

                retry+=1

        return result

    @staticmethod

    def bashExecute(command, wait_return=True, window = False, bash_opts=''):

        command = bash_opts + ' -l -c '  + command

        return Cygwin.execute(Cygwin.cygwin_bash, command, wait_return, window)

    @staticmethod

    def cmdExecute(command, wait_return=True, window = False, bash_opts=''):

        command = ' /c ' + command 

        return Cygwin.execute(Cygwin.win_cmd, command, wait_return, window)

    # executes command over ssh on guest vm

    @staticmethod

    def sshExecute(command, address, user_name, certificate, wait_return=True, window = False):

        command = ' -v -i "' + certificate + '" ' + user_name + '@' + address + ' ' + command        

        return Cygwin.execute(Cygwin.cygwin_ssh, command, wait_return, window)     

    #machineFolder + '/' + vm_name + '/dvm_key

    #address = self.getHostOnlyIP(vm_name)

    #machineFolder = self.getDefaultMachineFolder()

    #machineFolder = Cygwin.cygwinPath(machineFolder)

    # executes command over ssh on guest vm with X forwarding

    @staticmethod

    def sshExecuteX11(command, address, user_name, certificate, wait_return=True):

        return Cygwin.bashExecute('"DISPLAY=:0.0 /usr/bin/ssh -v -Y -i \\"' + certificate +'\\" ' + user_name + '@' + address + ' ' + command + '\"')

    @staticmethod

    def is_X11_running():

        """check if we can connect to a X11 running instance"""

        p = Cygwin.bashExecute('"DISPLAY=:0 /usr/bin/xset -q"')

        return p[0] == 0

    @staticmethod

    def start_X11():

        """start X11 in the background (if not already running) on DISPLAY=:0"""

        # do not start if already running

        if Cygwin.is_X11_running():

            return           

        # launch X11 (forget output and return immediately)

        return Cygwin.execute(Cygwin.cygwin_x11, ':0 -multiwindow', wait_return = False, window = False)

    @staticmethod    

    def cygPath(path):

        return Cygwin.bashExecute('"/usr/bin/cygpath -u \\"' + path + '\\""')[1].rstrip('\n')

# start

if __name__ == "__main__":

    logger = setupLogger('Cygwin')

    c = Cygwin()

    logger.info(c.root())

    logger.info(c.bin())

    logger.info(c.bash())

    logger.info(c.ssh())

    c.cygPath('C:')

    c.start_X11()