path: root/terminal.py

# Copyright (C) 2007, Eduardo Silva <edsiper@gmail.com>.
# Copyright (C) 2008, One Laptop Per Child
# Copyright (C) 2009, Ben Schwartz <bens@alum.mit.edu>
#
# 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 St, Fifth Floor, Boston, MA  02110-1301  USA

import os

import logging
from gettext import gettext as _

import gtk
import dbus

from sugar.activity import activity
from sugar import env
from sugar.graphics.toolbutton import ToolButton
from sugar.graphics.palette import Palette
import ConfigParser
import os.path

import vte
import pango

import telepathy
import shutil
import subprocess
import stat

import random
import re
import signal

SERVICE = 'org.sugarlabs.ShareTerm'
IFACE = SERVICE
PATH = '/org/sugarlabs/ShareTerm'

class SharedTerminalActivity(activity.Activity):

    def __init__(self, handle):
        activity.Activity.__init__(self, handle)
        
        self._logger = logging.getLogger('shareterm-activity')
        self._logger.debug('Starting the ShareTerm activity')
        
        self.set_title(_('ShareTerm Activity'))
        self.connect('key-press-event', self.__key_press_cb)

        toolbox = activity.ActivityToolbox(self)

        self._edit_toolbar = activity.EditToolbar()
        toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
        self._edit_toolbar.show()
        self._edit_toolbar.undo.props.visible = False
        self._edit_toolbar.redo.props.visible = False
        self._edit_toolbar.separator.props.visible = False
        self._edit_toolbar.copy.connect('clicked', self._copy_cb)
        self._edit_toolbar.paste.connect('clicked', self._paste_cb)

        activity_toolbar = toolbox.get_activity_toolbar()
        activity_toolbar.keep.props.visible = False

        self.set_toolbox(toolbox)
        toolbox.show()
        
        box = gtk.HBox(False, 4)

        self._vte = VTE()
        self._vte.set_scroll_on_keystroke(True)
        self._vte.connect("child-exited", lambda term: self.close())

        self._screenpid = None
        self._sshdaemon = None
        self._otherscreenpid = None
        
        if not self._shared_activity: #I am the initiator
            suffix = "ShareTerm%d" % random.getrandbits(32)
            os.putenv('SCREENDIR',os.path.join(os.getenv('HOME'),'.screen'))

            #I tried to use envv with fork_command here, but it causes the
            #command to die without explanation.  It seems to work without it, though.
            self._screenpid = self._vte.fork_command(command='screen', 
                      argv=['screen','-S',suffix,
                           '-c',os.path.join(activity.get_bundle_path(),'screenrc')])

            #Don't show the screen until Screen is active
            self._vte.show()

            #self._screenname = "%d.%s" % (self._screenpid, suffix)
            #The above line would be the logical way to determine the screenname.
            #Unfortunately, screen seems to fork before determining the pid to use here,
            #so the name computed this way has the wrong pid. Therefore, we must instead
            #search the list of existing screens for one matching our unique random
            #suffix.
            #Note that there will only be more than one screen for the current user
            #if Rainbow is not running.

            L = subprocess.Popen(['screen','-list'],stdout=subprocess.PIPE)
            r = re.compile(r"\s*((\d+)\.%s)" % suffix)
            for line in L.stdout:
                m = r.match(line)
                if m is not None:
                    self._screenname = m.group(1)
                    self._otherscreenpid = int(m.group(2))

            self._connected = True
            self.connect('shared', self._shared_cb)
        else: # I am joining
            self._connected = False
            if self.get_shared(): #Already joined for some reason
                self._joined_cb()
            else:
                self.connect('joined', self._joined_cb)

        scrollbar = gtk.VScrollbar(self._vte.get_adjustment())
        scrollbar.show()

        box.pack_start(self._vte)
        box.pack_start(scrollbar, False, False, 0)
        
        self.set_canvas(box)
        box.show()
        
        self._vte.grab_focus()

    def _copy_cb(self, button):
        if self._vte.get_has_selection():
            self._vte.copy_clipboard()

    def _paste_cb(self, button):
        self._vte.paste_clipboard()

    def __key_press_cb(self, window, event):
        if event.state & gtk.gdk.CONTROL_MASK and event.state & gtk.gdk.SHIFT_MASK:
        
            if gtk.gdk.keyval_name(event.keyval) == "C":
                if self._vte.get_has_selection():
                    self._vte.copy_clipboard()              
                return True
            elif gtk.gdk.keyval_name(event.keyval) == "V":
                self._vte.paste_clipboard()
                return True
                
        return False

    def _sharing_setup(self):
        # This section creates the authorized_keys file, containing the public key in
        # question.  This code must agree with sshd_config's AuthorizedKeysFile.
	home = os.getenv('HOME')
        self._sshdir = os.path.join(home,'.ShareTerm')
        os.mkdir(self._sshdir)
        os.chmod(self._sshdir,stat.S_IRWXU)
        bundle_path = activity.get_bundle_path()
        authkeys = os.path.join(self._sshdir,'authorized_keys')
        shutil.copyfile(os.path.join(bundle_path,'userkey.pub'), authkeys)
        os.chmod(authkeys,stat.S_IRUSR|stat.S_IWUSR)
        
        
        params = {}
        params['screenname'] = self._screenname
        params['username'] = os.getenv('USER')

        port = 5000
        listening = False
        while not listening:
            #FIXME: assumes sshd is in /usr/bin/sshd.  (Full path invocation is required
            #by sshd when running as non-root.)
            self._sshdaemon = subprocess.Popen(['/usr/sbin/sshd','-h',os.path.join(bundle_path,'hostkey'),
                                 '-f',os.path.join(bundle_path,'sshd_config'),
                                 '-p',str(port),'-D','-e'], stderr=subprocess.PIPE)
            x = self._sshdaemon.stderr.readline()
            #FIXME:  The following is an ugly hack, in attempt to determine
            #whether sshd successfully launched by observing its logging output.
            # It would be better if sshd used a return code to indicate whether it
            # had successfully daemonized or failed, but this does not seem to be
            # the case.
            success = 'Server listening'
            if x[:len(success)] == success:
                listening = True
            else: #failure; the daemon will stop itself
                self._sshdaemon.wait()
                port += 1
                if port == 65536:
                    break #FIXME: What should happen here?
        self._logger.debug('started sshd on port %d' % port)

        return (params, port)

    def _shared_cb(self, activity):
        self._logger.debug('My activity was shared')
        self.initiating = True
        (params, port) = self._sharing_setup()

        self._logger.debug('This is my activity: making a tube...')

        address = ('127.0.0.1', dbus.UInt16(port))

        tubes_chan = self._shared_activity.telepathy_tubes_chan
        id = tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferStreamTube(
            SERVICE, params, telepathy.SOCKET_ADDRESS_TYPE_IPV4, address,
            telepathy.SOCKET_ACCESS_CONTROL_LOCALHOST, 0)

    def _joined_cb(self, also_self):
        tubes_chan = self._shared_activity.telepathy_tubes_chan

        tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal('NewTube',
            self._new_tube_cb)
        tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes(
            reply_handler=self._list_tubes_reply_cb,
            error_handler=self._list_tubes_error_cb)

    def _new_tube_cb(self, tube_id, initiator, tube_type, service, params, state):
        self._logger.debug('New Tube')
        if ((tube_type == telepathy.TUBE_TYPE_STREAM) and
            (service == SERVICE) and (not self._connected)):
            tubes_chan = self._shared_activity.telepathy_tubes_chan
            iface = tubes_chan[telepathy.CHANNEL_TYPE_TUBES]
            addr = iface.AcceptStreamTube(tube_id,
                       telepathy.SOCKET_ADDRESS_TYPE_IPV4,
                       telepathy.SOCKET_ACCESS_CONTROL_LOCALHOST, 0)

            port = int(addr[1])
            username = str(params['username'])
            screenname = str(params['screenname'])
            bundle_path = activity.get_bundle_path()

            #self._vte.fork_command('ssh', '-l %s -F %s -p %d -i %s localhost'
            #           % (username, 
            #              os.path.join(bundle_path,'ssh_config'),
            #              port,
            #              os.path.join(bundle_path,'userkey')))
            # I would prefer to use fork_command, but it doesn't seem to work here
            # and I don't know why.
            self._vte.feed_child("ssh -l %s -F %s -p %d -i %s localhost\n"
                       % (username, 
                          os.path.join(bundle_path,'ssh_config'),
                          port,
                          os.path.join(bundle_path,'userkey')))
            # "SCREENDIR=" is necessary here because otherwise screen attempts to write
            # to /var/run/screen, which is not permitted by Rainbow
            self._vte.feed_child("SCREENDIR=$HOME/.screen screen -x %s\n" % screenname)
            self._connected = True
            # Now that we are connected and screen is up, we can show the screen
            self._vte.show()

    def _list_tubes_reply_cb(self, tubes):
        for tube_info in tubes:
            self._new_tube_cb(*tube_info)

    def _list_tubes_error_cb(self, e):
        self._logger.error('ListTubes() failed: %s' % e)

    def can_close(self):
        #self._sshdaemon.terminate() #This requires 2.6, so we can't use it yet.
        try:
            os.kill(self._sshdaemon.pid,signal.SIGTERM)
        except:
            pass
        try:
            os.kill(self._screenpid,signal.SIGTERM)
        except:
            pass
        try:
            os.kill(self._otherscreenpid,signal.SIGTERM)
        except:
            pass
        # Removing sshdir is only necessary in the absence of Rainbow, but in that case
        # it has the potential to break if multiple ShareTerm sessions
        # are in use simultaneously, and sshdir is deleted while still in use.
        # The FIXME would be to use a randomly generated per-session sshdir, if we 
        # really care.
        #try:
        #    shutil.rmtree(self._sshdir,ignore_errors=True)
        #except:
        #    pass
        return True
        

class VTE(vte.Terminal):
    def __init__(self):
        vte.Terminal.__init__(self)
        self._configure_vte()

        os.chdir(os.environ["HOME"])
        self.fork_command()

    def _configure_vte(self):
        conf = ConfigParser.ConfigParser()
        conf_file = os.path.join(env.get_profile_path(), 'terminalrc')
        
        if os.path.isfile(conf_file):
            f = open(conf_file, 'r')
            conf.readfp(f)
            f.close()
        else:
            conf.add_section('terminal')

        if conf.has_option('terminal', 'font'):
            font = conf.get('terminal', 'font')
        else:
            font = 'Monospace 8'
            conf.set('terminal', 'font', font)
        self.set_font(pango.FontDescription(font))

        if conf.has_option('terminal', 'fg_color'):
            fg_color = conf.get('terminal', 'fg_color')
        else:
            fg_color = '#000000'
            conf.set('terminal', 'fg_color', fg_color)
        if conf.has_option('terminal', 'bg_color'):
            bg_color = conf.get('terminal', 'bg_color')
        else:
            bg_color = '#FFFFFF'
            conf.set('terminal', 'bg_color', bg_color)
        self.set_colors(gtk.gdk.color_parse (fg_color),
                            gtk.gdk.color_parse (bg_color),
                            [])
                            
        if conf.has_option('terminal', 'cursor_blink'):
            blink = conf.getboolean('terminal', 'cursor_blink')
        else:
            blink = False
            conf.set('terminal', 'cursor_blink', blink)
        
        self.set_cursor_blinks(blink)

        if conf.has_option('terminal', 'bell'):
            bell = conf.getboolean('terminal', 'bell')
        else:
            bell = False
            conf.set('terminal', 'bell', bell)
        self.set_audible_bell(bell)
        
        if conf.has_option('terminal', 'scrollback_lines'):
            scrollback_lines = conf.getint('terminal', 'scrollback_lines')
        else:
            scrollback_lines = 1000
            conf.set('terminal', 'scrollback_lines', scrollback_lines)
            
        self.set_scrollback_lines(scrollback_lines)
        self.set_allow_bold(True)
        
        if conf.has_option('terminal', 'scroll_on_keystroke'):
            scroll_key = conf.getboolean('terminal', 'scroll_on_keystroke')
        else:
            scroll_key = False
            conf.set('terminal', 'scroll_on_keystroke', scroll_key)
        self.set_scroll_on_keystroke(scroll_key)

        if conf.has_option('terminal', 'scroll_on_output'):
            scroll_output = conf.getboolean('terminal', 'scroll_on_output')
        else:
            scroll_output = False
            conf.set('terminal', 'scroll_on_output', scroll_output)
        self.set_scroll_on_output(scroll_output)
        
        if conf.has_option('terminal', 'emulation'):
            emulation = conf.get('terminal', 'emulation')
        else:
            emulation = 'xterm'
            conf.set('terminal', 'emulation', emulation)
        self.set_emulation(emulation)

        if conf.has_option('terminal', 'visible_bell'):
            visible_bell = conf.getboolean('terminal', 'visible_bell')
        else:
            visible_bell = False
            conf.set('terminal', 'visible_bell', visible_bell)
        self.set_visible_bell(visible_bell)
        conf.write(open(conf_file, 'w'))

    def on_gconf_notification(self, client, cnxn_id, entry, what):
        self.reconfigure_vte()

    def on_vte_button_press(self, term, event):
        if event.button == 3:
            self.do_popup(event)
            return True

    def on_vte_popup_menu(self, term):
        pass