root/trunk/src/gajim.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
## src/gajim.py
##
## Copyright (C) 2003-2008 Yann Leboulanger <asterix AT lagaule.org>
## Copyright (C) 2004-2005 Vincent Hanquez <tab AT snarc.org>
## Copyright (C) 2005 Alex Podaras <bigpod AT gmail.com>
##                    Norman Rasmussen <norman AT rasmussen.co.za>
##                    Stéphan Kochen <stephan AT kochen.nl>
## Copyright (C) 2005-2006 Dimitur Kirov <dkirov AT gmail.com>
##                         Alex Mauer <hawke AT hawkesnest.net>
## Copyright (C) 2005-2007 Travis Shirk <travis AT pobox.com>
##                         Nikos Kouremenos <kourem AT gmail.com>
## Copyright (C) 2006 Junglecow J <junglecow AT gmail.com>
##                    Stefan Bethge <stefan AT lanpartei.de>
## Copyright (C) 2006-2008 Jean-Marie Traissard <jim AT lapin.org>
## Copyright (C) 2007 Lukas Petrovicky <lukas AT petrovicky.net>
##                    James Newton <redshodan AT gmail.com>
## Copyright (C) 2007-2008 Brendan Taylor <whateley AT gmail.com>
##                         Julien Pivotto <roidelapluie AT gmail.com>
##                         Stephan Erb <steve-e AT h3c.de>
## Copyright (C) 2008 Jonathan Schleifer <js-gajim AT webkeks.org>
##
## This file is part of Gajim.
##
## Gajim 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 3 only.
##
## Gajim 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 Gajim. If not, see <http://www.gnu.org/licenses/>.
##

import os

if os.name == 'nt':
        import warnings
        warnings.filterwarnings(action='ignore')

        if os.path.isdir('gtk'):
                # Used to create windows installer with GTK included
                paths = os.environ['PATH']
                list_ = paths.split(';')
                new_list = []
                for p in list_:
                        if p.find('gtk') < 0 and p.find('GTK') < 0:
                                new_list.append(p)
                new_list.insert(0, 'gtk/lib')
                new_list.insert(0, 'gtk/bin')
                os.environ['PATH'] = ';'.join(new_list)
                os.environ['GTK_BASEPATH'] = 'gtk'

import sys

if os.name == 'nt':
        # needed for docutils
        sys.path.append('.')

import logging
consoleloghandler = logging.StreamHandler()
consoleloghandler.setLevel(1)
consoleloghandler.setFormatter(
logging.Formatter('%(asctime)s %(name)s: %(levelname)s: %(message)s'))
log = logging.getLogger('gajim')
log.setLevel(logging.WARNING)
log.addHandler(consoleloghandler)
log.propagate = False
log = logging.getLogger('gajim.gajim')

# create intermediate loggers
logging.getLogger('gajim.c')
logging.getLogger('gajim.c.x')

import getopt
from common import i18n

def parseLogLevel(arg):
        if arg.isdigit():
                return int(arg)
        if arg.isupper():
                return getattr(logging, arg)
        raise ValueError(_('%s is not a valid loglevel'), repr(arg))

def parseLogTarget(arg):
        arg = arg.lower()
        if arg.startswith('.'): return arg[1:]
        if arg.startswith('gajim'): return arg
        return 'gajim.' + arg

def parseAndSetLogLevels(arg):
        for directive in arg.split(','):
                directive = directive.strip()
                targets, level = directive.rsplit('=', 1)
                level = parseLogLevel(level.strip())
                for target in targets.split('='):
                        target = parseLogTarget(target.strip())
                        if target == '':
                                consoleloghandler.setLevel(level)
                                print "consoleloghandler level set to %s" % level
                        else:
                                logger = logging.getLogger(target)
                                logger.setLevel(level)
                                print "Logger %s level set to %d" % (target, level)

def parseOpts():
        profile = ''
        verbose = False
        config_path = None

        try:
                shortargs = 'hqvl:p:c:'
                longargs = 'help quiet verbose loglevel= profile= config_path='
                opts, args = getopt.getopt(sys.argv[1:], shortargs, longargs.split())
        except getopt.error, msg:
                print msg
                print 'for help use --help'
                sys.exit(2)
        for o, a in opts:
                if o in ('-h', '--help'):
                        print 'gajim [--help] [--quiet] [--verbose] [--loglevel subsystem=level[,subsystem=level[...]]] [--profile name] [--config-path]'
                        sys.exit()
                elif o in ('-q', '--quiet'):
                        consoleloghandler.setLevel(logging.CRITICAL)
                        verbose = False
                elif o in ('-v', '--verbose'):
                        consoleloghandler.setLevel(logging.INFO)
                        verbose = True
                elif o in ('-p', '--profile'): # gajim --profile name
                        profile = a
                elif o in ('-l', '--loglevel'):
                        parseAndSetLogLevels(a)
                elif o in ('-c', '--config-path'):
                        config_path = a
        return profile, verbose, config_path

profile, verbose, config_path = parseOpts()
del parseOpts, parseAndSetLogLevels, parseLogTarget, parseLogLevel

import locale
profile = unicode(profile, locale.getpreferredencoding())

import common.configpaths
common.configpaths.gajimpaths.init(config_path)
del config_path
common.configpaths.gajimpaths.init_profile(profile)
del profile

# PyGTK2.10+ only throws a warning
import warnings
warnings.filterwarnings('error', module='gtk')
try:
        import gtk
except Warning, msg:
        if str(msg) == 'could not open display':
                print >> sys.stderr, _('Gajim needs X server to run. Quiting...')
                sys.exit()
warnings.resetwarnings()

if os.name == 'nt':
        import warnings
        warnings.filterwarnings(action='ignore')

pritext = ''

from common import exceptions
try:
        from common import gajim
except exceptions.DatabaseMalformed:
        pritext = _('Database Error')
        sectext = _('The database file (%s) cannot be read. Try to repair it (see http://trac.gajim.org/wiki/DatabaseBackup) or remove it (all history will be lost).') % common.logger.LOG_DB_PATH
else:
        from common import dbus_support
        if dbus_support.supported:
                import dbus

        if os.name == 'posix': # dl module is Unix Only
                try: # rename the process name to gajim
                        import dl
                        libc = dl.open('/lib/libc.so.6')
                        libc.call('prctl', 15, 'gajim\0', 0, 0, 0)
                except Exception:
                        pass

        if gtk.pygtk_version < (2, 8, 0):
                pritext = _('Gajim needs PyGTK 2.8 or above')
                sectext = _('Gajim needs PyGTK 2.8 or above to run. Quiting...')
        elif gtk.gtk_version < (2, 8, 0):
                pritext = _('Gajim needs GTK 2.8 or above')
                sectext = _('Gajim needs GTK 2.8 or above to run. Quiting...')

        try:
                import gtk.glade # check if user has libglade (in pygtk and in gtk)
        except ImportError:
                pritext = _('GTK+ runtime is missing libglade support')
                if os.name == 'nt':
                        sectext = _('Please remove your current GTK+ runtime and install the latest stable version from %s') % 'http://gladewin32.sourceforge.net'
                else:
                        sectext = _('Please make sure that GTK+ and PyGTK have libglade support in your system.')

        try:
                from common import check_paths
        except exceptions.PysqliteNotAvailable, e:
                pritext = _('Gajim needs PySQLite2 to run')
                sectext = str(e)

        if os.name == 'nt':
                try:
                        import winsound # windows-only built-in module for playing wav
                        import win32api # do NOT remove. we req this module
                except Exception:
                        pritext = _('Gajim needs pywin32 to run')
                        sectext = _('Please make sure that Pywin32 is installed on your system. You can get it at %s') % 'http://sourceforge.net/project/showfiles.php?group_id=78018'

if pritext:
        dlg = gtk.MessageDialog(None,
                gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL,
                gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, message_format = pritext)

        dlg.format_secondary_text(sectext)
        dlg.run()
        dlg.destroy()
        sys.exit()

del pritext

import gtkexcepthook

import gobject
if not hasattr(gobject, 'timeout_add_seconds'):
        def timeout_add_seconds_fake(time_sec, *args):
                return gobject.timeout_add(time_sec * 1000, *args)
        gobject.timeout_add_seconds = timeout_add_seconds_fake

import re
import signal
import time
import math

import gtkgui_helpers
import notify
import message_control

from chat_control import ChatControlBase
from chat_control import ChatControl
from groupchat_control import GroupchatControl
from groupchat_control import PrivateChatControl
from atom_window import AtomWindow
from session import ChatControlSession

import common.sleepy

from common.xmpp import idlequeue
from common.zeroconf import connection_zeroconf
from common import nslookup
from common import proxy65_manager
from common import socks5
from common import helpers
from common import optparser
from common import dataforms

if verbose: gajim.verbose = True
del verbose

gajimpaths = common.configpaths.gajimpaths

pid_filename = gajimpaths['PID_FILE']
config_filename = gajimpaths['CONFIG_FILE']

import traceback
import errno

import dialogs
def pid_alive():
        try:
                pf = open(pid_filename)
        except IOError:
                # probably file not found
                return False

        try:
                pid = int(pf.read().strip())
                pf.close()
        except Exception:
                traceback.print_exc()
                # PID file exists, but something happened trying to read PID
                # Could be 0.10 style empty PID file, so assume Gajim is running
                return True

        if os.name == 'nt':
                try:
                        from ctypes import (windll, c_ulong, c_int, Structure, c_char, POINTER, pointer, )
                except Exception:
                        return True

                class PROCESSENTRY32(Structure):
                        _fields_ = [
                                ('dwSize', c_ulong, ),
                                ('cntUsage', c_ulong, ),
                                ('th32ProcessID', c_ulong, ),
                                ('th32DefaultHeapID', c_ulong, ),
                                ('th32ModuleID', c_ulong, ),
                                ('cntThreads', c_ulong, ),
                                ('th32ParentProcessID', c_ulong, ),
                                ('pcPriClassBase', c_ulong, ),
                                ('dwFlags', c_ulong, ),
                                ('szExeFile', c_char*512, ),
                                ]
                        def __init__(self):
                                Structure.__init__(self, 512+9*4)

                k = windll.kernel32
                k.CreateToolhelp32Snapshot.argtypes = c_ulong, c_ulong,
                k.CreateToolhelp32Snapshot.restype = c_int
                k.Process32First.argtypes = c_int, POINTER(PROCESSENTRY32),
                k.Process32First.restype = c_int
                k.Process32Next.argtypes = c_int, POINTER(PROCESSENTRY32),
                k.Process32Next.restype = c_int

                def get_p(p):
                        h = k.CreateToolhelp32Snapshot(2, 0) # TH32CS_SNAPPROCESS
                        assert h > 0, 'CreateToolhelp32Snapshot failed'
                        b = pointer(PROCESSENTRY32())
                        f = k.Process32First(h, b)
                        while f:
                                if b.contents.th32ProcessID == p:
                                        return b.contents.szExeFile
                                f = k.Process32Next(h, b)

                if get_p(pid) in ('python.exe', 'gajim.exe'):
                        return True
                return False
        elif sys.platform == 'darwin':
                try:
                        from osx import checkPID
                        return checkPID(pid, 'Gajim.bin')
                except ImportError:
                        return
        try:
                if not os.path.exists('/proc'):
                        return True # no /proc, assume Gajim is running

                try:
                        f = open('/proc/%d/cmdline'% pid)
                except IOError, e:
                        if e.errno == errno.ENOENT:
                                return False # file/pid does not exist
                        raise

                n = f.read().lower()
                f.close()
                if n.find('gajim') < 0:
                        return False
                return True # Running Gajim found at pid
        except Exception:
                traceback.print_exc()

        # If we are here, pidfile exists, but some unexpected error occured.
        # Assume Gajim is running.
        return True

if pid_alive():
        path_to_file = os.path.join(gajim.DATA_DIR, 'pixmaps/gajim.png')
        pix = gtk.gdk.pixbuf_new_from_file(path_to_file)
        gtk.window_set_default_icon(pix) # set the icon to all newly opened wind
        pritext = _('Gajim is already running')
        sectext = _('Another instance of Gajim seems to be running\nRun anyway?')
        dialog = dialogs.YesNoDialog(pritext, sectext)
        dialog.popup()
        if dialog.run() != gtk.RESPONSE_YES:
                sys.exit(3)
        dialog.destroy()
        # run anyway, delete pid and useless global vars
        if os.path.exists(pid_filename):
                os.remove(pid_filename)
        del path_to_file
        del pix
        del pritext
        del sectext
        dialog.destroy()

# Create .gajim dir
pid_dir =  os.path.dirname(pid_filename)
if not os.path.exists(pid_dir):
        check_paths.create_path(pid_dir)
# Create pid file
try:
        f = open(pid_filename, 'w')
        f.write(str(os.getpid()))
        f.close()
except IOError, e:
        dlg = dialogs.ErrorDialog(_('Disk Write Error'), str(e))
        dlg.run()
        dlg.destroy()
        sys.exit()
del pid_dir
del f

def on_exit():
        # delete pid file on normal exit
        if os.path.exists(pid_filename):
                os.remove(pid_filename)
        # Save config
        gajim.interface.save_config()
        if sys.platform == 'darwin':
                try:
                        import osx
                        osx.shutdown()
                except ImportError:
                        pass

import atexit
atexit.register(on_exit)

parser = optparser.OptionsParser(config_filename)

import roster_window
import profile_window
import config

class GlibIdleQueue(idlequeue.IdleQueue):
        '''
        Extends IdleQueue to use glib io_add_wath, instead of select/poll
        In another, `non gui' implementation of Gajim IdleQueue can be used safetly.
        '''
        def init_idle(self):
                ''' this method is called at the end of class constructor.
                Creates a dict, which maps file/pipe/sock descriptor to glib event id'''
                self.events = {}
                # time() is already called in glib, we just get the last value
                # overrides IdleQueue.current_time()
                self.current_time = lambda: gobject.get_current_time()

        def add_idle(self, fd, flags):
                ''' this method is called when we plug a new idle object.
                Start listening for events from fd
                '''
                res = gobject.io_add_watch(fd, flags, self._process_events,
                        priority=gobject.PRIORITY_LOW)
                # store the id of the watch, so that we can remove it on unplug
                self.events[fd] = res

        def _process_events(self, fd, flags):
                try:
                        return self.process_events(fd, flags)
                except Exception:
                        self.remove_idle(fd)
                        self.add_idle(fd, flags)
                        raise

        def remove_idle(self, fd):
                ''' this method is called when we unplug a new idle object.
                Stop listening for events from fd
                '''
                if not fd in self.events:
                        return
                gobject.source_remove(self.events[fd])
                del(self.events[fd])

        def process(self):
                self.check_time_events()

class PassphraseRequest:
        def __init__(self, keyid):
                self.keyid = keyid
                self.callbacks = []
                self.dialog_created = False
                self.completed = False

        def run_callback(self, account, callback):
                gajim.connections[account].gpg_passphrase(self.passphrase)
                callback()

        def add_callback(self, account, cb):
                if self.completed:
                        self.run_callback(account, cb)
                else:
                        self.callbacks.append((account, cb))
                        if not self.dialog_created:
                                self.create_dialog(account)

        def complete(self, passphrase):
                self.passphrase = passphrase
                self.completed = True
                if passphrase is not None:
                        gobject.timeout_add_seconds(30, gajim.interface.forget_gpg_passphrase,
                                self.keyid)
                for (account, cb) in self.callbacks:
                        self.run_callback(account, cb)
                del self.callbacks

        def create_dialog(self, account):
                title = _('Passphrase Required')
                second = _('Enter GPG key passphrase for key %(keyid)s (account '
                        '%(account)s).') % {'keyid': self.keyid, 'account': account}

                def _cancel():
                        # user cancelled, continue without GPG
                        self.complete(None)

                def _ok(passphrase, checked, count):
                        if gajim.connections[account].test_gpg_passphrase(passphrase):
                                # passphrase is good
                                self.complete(passphrase)
                                return

                        if count < 3:
                                # ask again
                                dialogs.PassphraseDialog(_('Wrong Passphrase'),
                                        _('Please retype your GPG passphrase or press Cancel.'),
                                        ok_handler=(_ok, count + 1), cancel_handler=_cancel)
                        else:
                                # user failed 3 times, continue without GPG
                                self.complete(None)

                dialogs.PassphraseDialog(title, second, ok_handler=(_ok, 1),
                        cancel_handler=_cancel)
                self.dialog_created = True

class Interface:

################################################################################                
### Methods handling events from connection 
################################################################################        

        def handle_event_roster(self, account, data):
                #('ROSTER', account, array)
                # FIXME: Those methods depend to highly on each other
                # and the order in which they are called
                self.roster.fill_contacts_and_groups_dicts(data, account)
                self.roster.add_account_contacts(account)
                self.roster.fire_up_unread_messages_events(account)
                if self.remote_ctrl:
                        self.remote_ctrl.raise_signal('Roster', (account, data))

        def handle_event_warning(self, unused, data):
                #('WARNING', account, (title_text, section_text))
                dialogs.WarningDialog(data[0], data[1])

        def handle_event_error(self, unused, data):
                #('ERROR', account, (title_text, section_text))
                dialogs.ErrorDialog(data[0], data[1])

        def handle_event_information(self, unused, data):
                #('INFORMATION', account, (title_text, section_text))
                dialogs.InformationDialog(data[0], data[1])

        def handle_event_ask_new_nick(self, account, data):
                #('ASK_NEW_NICK', account, (room_jid,))
                room_jid = data[0]
                gc_control = self.msg_win_mgr.get_gc_control(room_jid, account)
                if not gc_control and \
                room_jid in self.minimized_controls[account]:
                        gc_control = self.minimized_controls[account][room_jid]
                if gc_control: # user may close the window before we are here
                        title = _('Unable to join group chat')
                        prompt = _('Your desired nickname in group chat %s is in use or '
                                'registered by another occupant.\nPlease specify another nickname '
                                'below:') % room_jid
                        gc_control.show_change_nick_input_dialog(title, prompt)

        def handle_event_http_auth(self, account, data):
                #('HTTP_AUTH', account, (method, url, transaction_id, iq_obj, msg))
                def response(account, iq_obj, answer):
                        self.dialog.destroy()
                        gajim.connections[account].build_http_auth_answer(iq_obj, answer)

                def on_yes(is_checked, account, iq_obj):
                        response(account, iq_obj, 'yes')

                sec_msg = _('Do you accept this request?')
                if gajim.get_number_of_connected_accounts() > 1:
                        sec_msg = _('Do you accept this request on account %s?') % account
                if data[4]:
                        sec_msg = data[4] + '\n' + sec_msg
                self.dialog = dialogs.YesNoDialog(_('HTTP (%(method)s) Authorization for '
                        '%(url)s (id: %(id)s)') % {'method': data[0], 'url': data[1],
                        'id': data[2]}, sec_msg, on_response_yes=(on_yes, account, data[3]),
                        on_response_no=(response, account, data[3], 'no'))

        def handle_event_error_answer(self, account, array):
                #('ERROR_ANSWER', account, (id, jid_from, errmsg, errcode))
                id, jid_from, errmsg, errcode = array
                if unicode(errcode) in ('403', '406') and id:
                        # show the error dialog
                        ft = self.instances['file_transfers']
                        sid = id
                        if len(id) > 3 and id[2] == '_':
                                sid = id[3:]
                        if sid in ft.files_props['s']:
                                file_props = ft.files_props['s'][sid]
                                file_props['error'] = -4
                                self.handle_event_file_request_error(account,
                                        (jid_from, file_props, errmsg))
                                conn = gajim.connections[account]
                                conn.disconnect_transfer(file_props)
                                return
                elif unicode(errcode) == '404':
                        conn = gajim.connections[account]
                        sid = id
                        if len(id) > 3 and id[2] == '_':
                                sid = id[3:]
                        if sid in conn.files_props:
                                file_props = conn.files_props[sid]
                                self.handle_event_file_send_error(account,
                                        (jid_from, file_props))
                                conn.disconnect_transfer(file_props)
                                return

                ctrl = self.msg_win_mgr.get_control(jid_from, account)
                if ctrl and ctrl.type_id == message_control.TYPE_GC:
                        ctrl.print_conversation('Error %s: %s' % (array[2], array[1]))

        def handle_event_con_type(self, account, con_type):
                # ('CON_TYPE', account, con_type) which can be 'ssl', 'tls', 'tcp'
                gajim.con_types[account] = con_type
                self.roster.draw_account(account)

        def handle_event_connection_lost(self, account, array):
                # ('CONNECTION_LOST', account, [title, text])
                path = os.path.join(gajim.DATA_DIR, 'pixmaps', 'events',
                        'connection_lost.png')
                path = gtkgui_helpers.get_path_to_generic_or_avatar(path)
                notify.popup(_('Connection Failed'), account, account,
                        'connection_failed', path, array[0], array[1])

        def unblock_signed_in_notifications(self, account):
                gajim.block_signed_in_notifications[account] = False

        def handle_event_status(self, account, status): # OUR status
                #('STATUS', account, status)
                model = self.roster.status_combobox.get_model()
                if status == 'offline':
                        # sensitivity for this menuitem
                        if gajim.get_number_of_connected_accounts() == 0:
                                model[self.roster.status_message_menuitem_iter][3] = False
                        gajim.block_signed_in_notifications[account] = True
                else:
                        # 30 seconds after we change our status to sth else than offline
                        # we stop blocking notifications of any kind
                        # this prevents from getting the roster items as 'just signed in'
                        # contacts. 30 seconds should be enough time
                        gobject.timeout_add_seconds(30, self.unblock_signed_in_notifications, account)
                        # sensitivity for this menuitem
                        model[self.roster.status_message_menuitem_iter][3] = True

                # Inform all controls for this account of the connection state change
                ctrls = self.msg_win_mgr.get_controls()
                if account in self.minimized_controls:
                        # Can not be the case when we remove account
                        ctrls += self.minimized_controls[account].values()
                for ctrl in ctrls:
                        if ctrl.account == account:
                                if status == 'offline'