#!/usr/bin/python #~ JollyBOX chat+ client #~ Copyright (C) 2006 Thomas Jollans #~ #~ This program is free software; you can redistribute it and/or modify #~ it under the terms of the GNU General Public License version 2 as #~ published by the Free Software Foundation #~ #~ 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 def printwrapper ( str ): print str # --- IMPORTS from socket import * import select import sys import time import os import re # --- GLOBAL VARIABLES --- # list of functions to be called in main loop loopfuncz = [] # --- CONSTANTS TJC_DEFAULT_PORT = 4056 # --- CONSTANTS FOR ChatRoom --- # passed on to 'info' callback TJC_INFO_ROOMNAME = 0 # 'data' is the name of the room TJC_INFO_CLIENTS = 1 # 'data' is a list containing the names of the connected clients ; can be used for ChatRoom.request_info TJC_INFO_VERSION = 2 # 'data' is a string containing the server's version ; can be used for ChatRoom.request_info # passed on to 'user_status' callback TJC_USER_NEW = 0 # 'data' is the name of the user TJC_USER_GONE = 1 # 'data' is the name of the user class ChatRoom: """A TjChat chat room""" # --- CONSTRCTOR --- def __init__ ( self, server, port, name ): # default callbacks self.__printfn = printwrapper self.__msgfn = self.__display_msg self.__userstatfn = self.__printuserstat self.__infofn = self.__printinfo self.__privarrivfn = self.__priv_arrives self.__privdepartfn = self.__priv_departs self.__shutdownfn = sys.exit self.__alive = True self.__buf = [] self.__sock = socket(AF_INET, SOCK_STREAM) self.__printfn ( "-- socket initialized" ) self.__sock.connect ( ( gethostbyname ( server ), port ) ) self.__name = name self.__server = getfqdn ( server ) self.__port = port self.__server_caps = [] self.__name = name self.__proto = TjChatProtocol(self) self.__proto.send_name() print "--connected and sent initial info" # --- CALLBACKS --- def print_cb ( self, fn ): """callback prints text on preferred medium, equivalent to 'print' callback signature: def printfn ( text )""" self.__printfn = fn def msg_cb ( self, fn ): """notifies the arrival or departure of a standard message. callback signature: def msgfn ( author, message )""" self.__msgfn = fn def user_status_cb ( self, fn ): """notifies of a user-related event, e.g. a new user connecting. callback signature: def userstatfn ( type, data ) where type is one of the TJC_USER_* constants. the type of data is denoted next to the constant definition.""" self.__userstatfn = fn def info_cb ( self, fn ): """notifies the arrival of informational data. callback signature: def infofn ( type, data ) where type is one of the TJC_INFO_* constants. the type of data is denoted next to the constant definition.""" self.__infofn = fn def private_arriv_cb ( self, fn ): """notifies the arrival of a private message. callback signature: def privmsgfn ( author, message )""" self.__privarrivfn = fn def private_depart_cb ( self, fn ): """notifies the departure of a private message. callback signature: def privdepartfn ( recieptent, message )""" self.__privdepartfn = fn def shutdown_cb ( self, fn ): """called when the server closed the connection or the connection is not writable. callback signature: def privdepartfn ( )""" self.__shutdownfn = fn # --- FUNCTIONS FOR ChatRoom USAGE --- def main_iteration ( self ): if ( self.__alive ): r, w, ex = select.select ( [self.__sock], [self.__sock], [],0 ) if r: self.__proto.parse ( r[0].recv(256) ) if w and self.__buf: # workaround around bad protocol design # may fail on slow connexions time.sleep (0.1) writethis = self.__buf.pop() try: w[0].send( writethis ) except: # write error. let's commit suicide ! self.disconnect() self.__shutdownfn() def disconnect ( self ): self.__alive = False self.__sock.close () def send_msg ( self, msg ): self.__proto.send_msg(msg) self.__msgfn ( self.__name, msg ) def send_private_msg ( self, to, msg ): self.__proto.send_private_msg(to, msg) self.__privdepartfn ( to, msg ) def request_info ( self, type ): if type == TJC_INFO_CLIENTS: self.__proto.send_special( "#client-list" ) elif type == TJC_INFO_VERSION: self.__proto.send_special( "#server-version" ) def get_name ( self ): return self.__name def get_server ( self ): return self.__server def get_port ( self ): return self.__port # --- INTERNAL FUNCTIONS --- def __handle_special ( self, code, string ): if code == "welcome_to_room": self.__infofn ( TJC_INFO_ROOMNAME, string ) elif code == "new": self.__userstatfn ( TJC_USER_NEW, string ) elif code == "hasleft": self.__userstatfn ( TJC_USER_GONE, string ) elif code == "version": if '//' in string: ver, meta = string.split('//', 1) else: ver,meta = string,'' self.__server_caps = meta.split() self.__infofn ( TJC_INFO_VERSION, str(ver) ) # protocols ? if 'EXT:protocol' in self.__server_caps: self.__proto.send_special( ".protocol-list" ) print "protocol list requested" else: print "protocols extension not supported. (%s)" % self.__server_caps elif code == "protocol-list": if 'chat+pr0' in string: #something we like and understand. self.__proto.send_special( ".protocol-set", "chat+pr0" ) print "switching to chat+pr0" else: print string elif code == "protocol-ok": if string == "chat+pr0": self.__proto = ChatPlusProtocol0(self) print "switched to chat+pr0" elif code == "names": if not isinstance(string,list): string = [string] self.__infofn ( TJC_INFO_CLIENTS, string ) elif code == "close": # the server is telling me to commit suicide. self.disconnect() self.__shutdownfn() else: self.__printfn ( "SPECIAL [ " + code + " ] " + string ) def __buffer ( self, str ): self.__buf.insert ( 0, str ) # --- CALLBACK FALLBACKS def __display_msg ( self, author, msg ): self.__printfn ( "<" + author + "> " + msg ) def __printuserstat ( self, type, data ): if type == TJC_USER_NEW: self.__printfn ( "NEW USER: " + data ) elif type == TJC_USER_GONE: self.__printfn ( "USER HAS LEFT: " + data ) else: self.__printfn ( "USER STATUS INFO CODE " + str (type) + ": " + str (data ) ) def __printinfo ( self, type, data ): if type == TJC_INFO_ROOMNAME: self.__printfn ( "WELCOME TO ROOM " + data ) elif type == TJC_INFO_CLIENTS: self.__printfn ( "CONNECTED CLIENTS:" + ", ".join ( data ) ) elif type == TJC_INFO_VERSION: self.__printfn ( "SERVER VERSION IS: " + data ) else: self.__printfn ( "INFORMATION MSG CODE " + str (type) + ": " + str (data ) ) def __priv_arrives ( self, author, msg ): self.__printfn ( "PRIVATE FROM " + author + ": " + msg ) def __priv_departs ( self, recpt, msg ): self.__printfn ( "PRIVATE TO " + recpt + ": " + msg ) class TjChatProtocol: def __init__(self, room): self.room = room def __buffer(self, str): self.room._ChatRoom__buffer(str.encode('utf-16-le')) def send_msg ( self, msg ): self.__buffer ( "$" + self.room._ChatRoom__name + ";" + msg + "$" ) def send_private_msg ( self, to, msg ): self.__buffer ( "$" + self.room._ChatRoom__name + "~" + to + ";" + msg + "$") def send_special ( self, code, content = None ): if isinstance(content, basestring): code = code+';'+content if isinstance(content, list): code = code+';'+'~'.join(content) print repr("$@" + self.room._ChatRoom__name + ";" + code + "$") self.__buffer ( "$@" + self.room._ChatRoom__name + ";" + code + "$" ) def send_name ( self ): self.__buffer ( "$" + self.room._ChatRoom__name + "$" ) def parse ( self, string ): #time.sleep(.2) s = string.decode( "utf-16-le" ).strip() if len ( s ) == 0: # probably EOF. let's commit suicide ! self.room.disconnect() self.room._ChatRoom__shutdownfn() return if s[0] == '$' and s[-1] == '$' : #check if valid if re.match(r'^\$@.+;.+\$\$@.+;.+\$$', s): ss = s.split('$$', 1) self.parse(s[0]+'$') self.parse('$'+s[1]) return p1, p2 = s[1:][:-1].split(';', 1) if p1[0] == "~": self.room._ChatRoom__privarrivfn ( p1[1:], p2 ) #self.__printfn ( "PRIV [" + p1 [1:] + "] " + p2 ) elif p1[0] == "@": if '~' in p2: p2 = p2.split('~') self.room._ChatRoom__handle_special (p1[1:], p2) else: self.room._ChatRoom__msgfn ( p1, p2 ) class ChatPlusProtocol0: def __init__(self, room): self.room = room self.old = '' def __buffer(self, str): self.room._ChatRoom__buffer(str.encode('utf-8')) def send_msg ( self, msg ): self.__buffer ( "MESSAGE;%s\x1e" % msg ) def send_private_msg ( self, to, msg ): self.__buffer ( "PRIVATE;%s;%s\x1e" % (to,msg) ) def send_special ( self, code, content = None ): if isinstance(content, basestring): code = code+';'+content if isinstance(content, list): code = code+';'+'\x1f'.join(content) self.__buffer ( "SPECIAL;%s\x1e" % code ) def send_name ( self ): pass #not implemented in protocol def parse ( self, string ): s = string.decode( "utf-8" ) if len ( s ) == 0: # probably EOF. let's commit suicide ! self.room.disconnect() self.room._ChatRoom__shutdownfn() return strs = s.split('\x1e') strs[0] = self.old + strs[0] # get possible left-over chars from last time self.old = strs.pop() # the last is empty if there was a terminating RS, otherwise it's incomplete. for s in strs: prts = s.split(';') if prts[0] == 'MESSAGE': self.room._ChatRoom__msgfn ( prts[1], ';'.join(prts[2:]) ) elif prts[0] == 'PRIVATE': self.room._ChatRoom__privarrivfn ( prts[1], ';'.join(prts[2:]) ) elif prts[0] == 'SPECIAL': data = ';'.join(prts[2:]) if '\x1f' in data: data = data.split('\x1f') self.room._ChatRoom__handle_special (prts[1], data) if __name__ == "__main__": print "to start the GTK+ GUI, run gtkchat.py; for other UIs, wait." sys.exit(1)