import urllib
import socket
# md5 is deprecated in favour of hashlib since python 2.5; hashlib was
# introduced in python 2.5
try:
from hashlib import md5
except ImportError:
from md5 import md5
import msnlib
"""
This is the home for the msn callback class and examples (that might move to
another file in the near future).
There are three types of callbacks: the error one (this is only one), the
server ones (handle connections, notifications, lists and stuff like that),
and the switchboard ones (which handle messaging).
All of them receive as their first argument an 'md' (msn descriptor) that is
the main connection object; you probably already know what it is.
The models are:
error: def cb_err(md, errno, params)
server: def cb_def(md, type, tid, params)
switchboard: def cb_usr(md, type, tid, params, sbd)
See below for more examples.
Probably you should base your own callbacks on these ones, at least they were
thought with that in mind, so you can use yours as wrappers that handle only
your app-specific code and forget about the protocol-specific mess.
"""
# use the debug function from msnlib
debug = msnlib.debug
class cb:
def __init__(self):
self.unk = cb_unk # unknown
self.err = cb_err # server error
self.msg = cb_msg # get a message
self.notice = cb_notice # notice notification
self.chl = cb_chl # challenge
self.qry = cb_ign # query response
self.iln = cb_iln # status notification
self.chg = cb_ign # status change
self.nln = cb_nln # status notification
self.fln = cb_fln # status offline
self.out = cb_out # disconnect
self.blp = cb_ign # privacy mode change
self.lst = cb_lst # list requests
self.bpr = cb_bpr # user info
self.gtc = cb_ign # add notification
self.syn = cb_syn # list sync confirmation
self.prp = cb_prp # private info
self.lsg = cb_lsg # group list
self.add = cb_add # user add
self.rem = cb_rem # user remove
self.adg = cb_adg # group add
self.rmg = cb_rmg # group del
self.reg = cb_reg # group rename
self.rea = cb_rea # nick change
self.rng = cb_rng # switchboard invitation
self.iro = cb_iro # multi-user chat
self.ans = cb_ans # answer confirmation
self.xfr = cb_xfr # switchboard request
self.usr = cb_usr # sb request initial identification
self.cal = cb_ign # call confirmation
self.joi = cb_joi # session join
self.ack = cb_ack # message acknowledge
self.nak = cb_nak # message negative acknowledge
self.bye = cb_bye # switchboard user disconnect
self.qng = cb_qng # pong!
error_table = {
-10: 'Local error',
200: 'Syntax error',
201: 'Invalid parameter',
205: 'Invalid user',
206: 'Domain name missing',
207: 'Already logged in',
208: 'Invalid username',
209: 'Invalid fusername',
210: 'User list full',
215: 'User already there',
216: 'User already on list',
217: 'User not online',
218: 'Already in mode',
219: 'User is in the opposite list',
280: 'Switchboard failed',
281: 'Transfer to switchboard failed',
300: 'Required field missing',
302: 'Not logged in',
500: 'Internal server error',
501: 'Database server error',
510: 'File operation failed',
520: 'Memory allocation failed',
600: 'Server is busy',
601: 'Server is unavaliable',
602: 'Peer nameserver is down',
603: 'Database connection failed',
604: 'Server is going down',
707: 'Could not create connection',
711: 'Write is blocking',
712: 'Session is overloaded',
713: 'Too many active users',
714: 'Too many sessions',
715: 'Not expected',
717: 'Bad friend file',
911: 'Authentication failed',
913: 'Not allowed when offline',
920: 'Not accepting new users',
}
#
# Possible exceptions
#
class CallbackMess (Exception):
pass
class SYNError (Exception):
pass
class XFRError (Exception):
pass
#
# Callbacks
#
def cb_err(md, errno, params):
"Handle server errors"
if not error_table.has_key(errno):
desc = 'Unknown error %d' % errno
else:
desc = error_table[errno]
debug('SERVER ERROR %d: %s - %s' % (errno, desc, params))
def cb_def(md, type, tid, params):
"Default callback. It just prints the args"
debug('DEFAULT type: ' + type + ' :: Params: ' + str(params))
def cb_unk(md, type, tid, params):
"Handles the unknown types"
debug('Error! unknown event type "%s"' % type)
debug('params: ' + str(params))
def cb_chl(md, type, tid, params):
"Handles the challenges"
if type != 'CHL':
raise CallbackMess, (md, type, params)
hash = params + 'VT6PX?UQTM4WM%YR' # magic from www.hypothetic.org
hash = md5(hash).hexdigest()
md._send('QRY', 'PROD0038W!61ZTF9 32')
md.fd.send(hash)
def cb_ign(md, type, tid, params, nd = None):
"Ignores"
pass
def cb_out(md, type, tid, params):
"Server disconnected us"
debug('!!! Server closed the connection: ' + params)
def cb_iln(md, type, tid, params):
"Handles a friend status change"
t = params.split(' ')
status = t[0]
email = t[1]
if len(params) > 2: nick = urllib.unquote(t[2])
else: nick = ''
md.users[email].status = status
md.users[email].realnick = nick
debug('FRIEND %s (%s) changed status to :%s:' % (nick, email, status))
def cb_fln(md, type, tid, params):
"Handles a friend disconnection"
email = tid
debug('FRIEND %s disconnected (%s)' % (email, type))
md.users[email].status = type
def cb_nln(md, type, tid, params):
"Handles a friend status change"
status = tid
t = params.split(' ')
email = t[0]
if len(t) > 1: nick = urllib.unquote(t[1])
else: nick = ''
md.users[email].status = status
md.users[email].realnick = nick
debug('FRIEND %s (%s) changed status to :%s:' % (nick, email, status))
def cb_bpr(md, type, tid, params):
"Update friend info"
# the email is deduced from the last lst we got; if it's None it means
# that we come from an add (the protocol behaves different if coming
# from SYN or ADD)
email = md._last_lst
if email:
# we come from SYN
type = tid
param = urllib.unquote(params)
else:
# we come from ADD
t = params.split(' ')
email = t[0]
type = t[1]
if len(t) >= 3:
param = urllib.unquote(t[2])
else:
param = ''
if not md.users.has_key(email): return
if type == 'PHH': md.users[email].homep = param
elif type == 'PHW': md.users[email].workp = param
elif type == 'PHM': md.users[email].mobilep = param
else: pass
def cb_syn(md, type, tid, params):
"Receive a SYN notification"
t = params.split()
if len(t) != 3:
raise SYNError
lver = int(t[0])
total = int(t[1])
ngroups = int(t[2])
md.syn_lver = lver
md.syn_total = total
md.syn_ngroups = ngroups
def cb_lst(md, type, tid, params):
p = params.split(' ')
email = tid
nick = urllib.unquote(p[0])
listmask = int(p[1])
if len(p) == 3:
groups = p[2]
else:
groups = '0'
# we only use one main group id
gid = groups.split(',')[0]
if email in md.users.keys():
user = md.users[email]
else:
user = msnlib.user(email, nick, gid)
# the list mask is a bitmask, composed of:
# FL: 1
# AL: 2
# BL: 4
# RL: 8
# in forward
if listmask & 1:
user.lists.append('F')
md.users[email] = user
# in reverse
if listmask & 8:
user.lists.append('R')
md.reverse[email] = user
# in allow
if listmask & 2:
user.lists.append('A')
# in block
if listmask & 4:
user.lists.append('B')
md.lst_total += 1
# save in the global last_lst the email, because BPRs might need it
md._last_lst = email
def cb_lsg(md, type, tid, params):
"Handles group list"
p = params.split(' ')
gid = tid
name, unk = p[0:]
# if we get the group 0, start from scratch
if gid == '0':
md.groups = {}
name = urllib.unquote(name)
md.groups[gid] = name
def cb_prp(md, type, tid, params):
"Handles private info"
t = params.split(' ')
type = t[0]
if len(t) > 1: param = urllib.unquote(t[1])
else: param = ''
if type == 'PHH': md.homep = param
elif type == 'PHW': md.workp = param
elif type == 'PHM': md.mobilep = param
else: pass
def cb_add(md, type, tid, params):
"Handles a user add; both you adding a user and a user adding you"
t = params.split(' ')
type = t[0]
if type == 'RL':
email = t[2]
nick = urllib.unquote(t[3])
debug('ADD: %s (%s) added you' % (nick, email))
elif type == 'FL':
email = t[2]
nick = urllib.unquote(t[3])
gid = t[4]
md.users[email] = msnlib.user(email, nick, gid)
# put None in last_lst so BPRs know it's not coming from sync
md._last_lst = None
debug('ADD: adding %s (%s)' % (email, nick))
else:
pass
def cb_rem(md, type, tid, params):
"""Handles a user del.
Only make something in the case of a user removing you"""
t = params.split(' ')
type = t[0]
if type == 'RL':
email = t[2]
debug('REM: %s removed you' % email)
elif type == 'FL':
email = t[2]
if md.users[email].sbd:
md.close(md.users[email].sbd)
del(md.users[email])
debug('REM: removing %s' % email)
else:
pass
def cb_adg(md, type, tid, params):
"Handle a group add"
t = params.split(' ')
lver, name, gid = t[0:3]
md.groups[gid] = name
debug('ADG: group %s (%s) added' % (name, gid))
def cb_rmg(md, type, tid, params):
"Handle a group del"
t = params.split(' ')
lver, gid = t[0:2]
for e in md.users.keys():
if md.users[e].gid == gid:
if md.users[e].sbd:
md.close(md.users[e].sbd)
del(md.users[e])
del(md.groups[gid])
debug('RMG: group %s removed' % gid)
def cb_reg(md, type, tid, params):
"Handle a group rename"
t = params.split(' ')
gid = t[1]
name = t[2]
md.groups[gid] = name
debug('REG: group %s renamed to %s' % (name, gid))
def cb_rea(md, type, tid, params):
"Handles our info change"
t = params.split(' ')
email = t[1]
nick = urllib.unquote(t[2])
if email != md.email:
md.users[email].nick = nick
else:
md.nick = nick
debug('NICK CHANGE: email %s - nick %s' % (email, nick))
def cb_rng(md, type, tid, params):
"Handles switchboard invitations."
t = params.split(' ')
sid = tid
ip, port = t[0].split(':')
port = int(port)
hash = t[2]
email = t[3]
fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# we set the socket nonblocking so we don't block (duh!) on connect();
# it will be picked up later from the select loop and handled via the
# main read() call, which you will have to see to find out the rest.
fd.setblocking(0)
fd.connect_ex((ip, port))
sbd = msnlib.sbd()
sbd.fd = fd
sbd.block = 0
sbd.state = 'cp'
sbd.type = 'answer'
sbd.endpoint = (ip, port)
sbd.emails.append(email)
sbd.hash = hash
sbd.session_id = sid
md.submit_sbd(sbd) # it has the connect pending
def cb_xfr(md, type, tid, params):
"Handles switchboard requests"
t = params.split(' ')
ip, port = t[1].split(':')
port = int(port)
hash = t[3]
fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
fd.setblocking(0) # see cb_rng
fd.connect_ex((ip, port))
# look for the sbd, matching the tid
sbd = None
for i in md.sb_fds:
if i.state == 'xf' and i.orig_tid == tid:
sbd = i
break
if not sbd:
debug('AIEEE: XFR without sbd!')
raise XFRError, (type, tid, params)
sbd.fd = fd
sbd.block = 0
sbd.state = 'cp'
sbd.endpoint = (ip, port)
sbd.hash = hash
def cb_iro(md, type, tid, params, sbd):
"Handles the switchboard participant list"
p = params.split(' ')
uid, ucount, email, nick = p
if ucount == '1':
# do nothing if we only have one participant
return
else:
if email not in md.users.keys():
md.users[email] = msnlib.user(email)
if email not in sbd.emails:
sbd.emails.append(email)
debug("FRIEND %s joined chat with %s" % (email, sbd.emails[0]))
def cb_usr(md, type, tid, params, sbd):
"Handles switchboard requests initial identification"
email = sbd.emails[0]
md._send('CAL', email, sbd)
sbd.state = 'ca'
def cb_joi(md, type, tid, params, sbd):
"Handles a switchboard join, and sends the pending messages"
email = tid
# if it's a multi-user chat, just append it to the list
if sbd.emails and email != sbd.emails[0]:
sbd.emails.append(email)
if email not in md.users.keys():
md.users[email] = msnlib.user(email)
debug('CALL: user %s joined chat with %s' % \
(email, sbd.emails[0]))
# otherwise (common path) set up the sbd and flush the messages
else:
sbd.state = 'es'
debug('CALL: user %s replied your chat request; flushing' % email)
md.sendmsg(email)
debug('CALL: message queue for %s flushed' % email)
def cb_ans(md, type, tid, params, sbd):
"""Answer confirmation to an invitation, replied after the connect()
ending by read()"""
sbd.state = 'es'
def cb_msg(md, type, tid, params, sbd):
"Get a message"
debug('MESSAGE\n+++ Header: %s\n%s\n\n' % (str(tid), str(params)))
def cb_ack(md, type, tid, params, sbd):
"Get a message acknowledge"
debug('ACK: tid:%s' % tid)
def cb_notice(md, type, tid, params, sbd):
"Get a notice"
debug('NOTICE\n+++ %s\n\n' % str(params))
def cb_nak(md, type, tid, params, sbd):
"Get a message negative acknowledge"
debug('NAK: tid:%s' % tid)
def cb_bye(md, type, tid, params, sbd):
"Handles a user sb disconnect"
email = tid
if email != sbd.emails[0]:
debug('BYE: user %s leaving sbd' % email)
if email in sbd.emails:
sbd.emails.remove(email)
else:
debug('BYE: closing %s' % str(sbd))
md.close(sbd)
def cb_qng(md, type, tid, params):
"Get the response of a ping"
debug('PONG!: answered by the server')