1 # Twisted, the Framework of Your Internet
2 # Copyright (C) 2001-2002 Matthew W. Lefkowitz
3 # Copyright (C) 2004-2005 James C. Bunton
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of version 2.1 of the GNU Lesser General Public
7 # License as published by the Free Software Foundation.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 MSNP11 Protocol (client only) - semi-experimental
24 This module provides support for clients using the MSN Protocol (MSNP11).
25 There are basically 3 servers involved in any MSN session:
29 The DispatchClient class handles connections to the
30 dispatch server, which basically delegates users to a
31 suitable notification server.
33 You will want to subclass this and handle the gotNotificationReferral
36 I{Notification Server}
38 The NotificationClient class handles connections to the
39 notification server, which acts as a session server
40 (state updates, message negotiation etc...)
44 The SwitchboardClient handles connections to switchboard
45 servers which are used to conduct conversations with other users.
47 There are also two classes (FileSend and FileReceive) used
50 Clients handle events in two ways.
52 - each client request requiring a response will return a Deferred,
53 the callback for same will be fired when the server sends the
55 - Events which are not in response to any client request have
56 respective methods which should be overridden and handled in
59 Most client request callbacks require more than one argument,
60 and since Deferreds can only pass the callback one result,
61 most of the time the callback argument will be a tuple of
62 values (documented in the respective request method).
63 To make reading/writing code easier, callbacks can be defined in
64 a number of ways to handle this 'cleanly'. One way would be to
65 define methods like: def callBack(self, (arg1, arg2, arg)): ...
66 another way would be to do something like:
67 d.addCallback(lambda result: myCallback(*result)).
69 If the server sends an error response to a client request,
70 the errback of the corresponding Deferred will be called,
71 the argument being the corresponding error code.
74 Due to the lack of an official spec for MSNP11, extra checking
75 than may be deemed necessary often takes place considering the
76 server is never 'wrong'. Thus, if gotBadLine (in any of the 3
77 main clients) is called, or an MSNProtocolError is raised, it's
78 probably a good idea to submit a bug report. ;)
79 Use of this module requires that PyOpenSSL is installed.
81 @author: U{Sam Jordan<mailto:sam@twistedmatrix.com>}
82 @author: U{James Bunton<mailto:james@delx.cjb.net>}
85 from __future__
import nested_scopes
88 from twisted
.protocols
.basic
import LineReceiver
90 from twisted
.web
.http
import HTTPClient
93 from twisted
.protocols
.http
import HTTPClient
95 print "Couldn't find a HTTPClient. If you're using Twisted 2.0 make sure you've installed twisted.web"
100 from twisted
.internet
import reactor
, task
101 from twisted
.internet
.defer
import Deferred
102 from twisted
.internet
.protocol
import ClientFactory
104 from twisted
.internet
.ssl
import ClientContextFactory
106 print "You must install pycrypto and pyopenssl."
108 from twisted
.python
import failure
, log
111 from tlib
import xmlw
114 import types
, operator
, os
, sys
, base64
, random
, struct
, random
, sha
, base64
, StringIO
, array
, codecs
, binascii
115 from urllib
import quote
, unquote
118 MSN_PROTOCOL_VERSION
= "MSNP11 CVR0" # protocol version
119 MSN_PORT
= 1863 # default dispatch server port
120 MSN_MAX_MESSAGE
= 1664 # max message length
121 MSN_CVR_STR
= "0x040c winnt 5.1 i386 MSNMSGR 7.0.0777 msmsgs"
122 MSN_AVATAR_GUID
= "{A4268EEC-FEC5-49E5-95C3-F126696BDBF6}"
123 MSN_MSNFTP_GUID
= "{5D3E02AB-6190-11D3-BBBB-00C04F795683}"
145 STATUS_ONLINE
= 'NLN'
146 STATUS_OFFLINE
= 'FLN'
147 STATUS_HIDDEN
= 'HDN'
168 P2PSEQ
= [-3, -2, 0, -1, 1, 2, 3, 4, 5, 6, 7, 8]
177 return inp
.split('=')[1]
189 userHandle
= getVal(p
)
191 screenName
= unquote(getVal(p
))
196 else: # Must be the groups
198 groups
= p
.split(',')
200 raise MSNProtocolError
, "Unknown LST/ADC response" + str(params
) # debug
202 return userHandle
, screenName
, userGuid
, lists
, groups
205 """ Needed for Python 2.3 compatibility """
206 return s
+ (n
-len(s
))*c
208 if sys
.byteorder
== "little":
210 """ Encodes to utf-16 and ensures network byte order. Strips the BOM """
211 a
= array
.array("h", s
.encode("utf-16")[2:])
216 """ Encodes to utf-16 and ensures network byte order. Strips the BOM """
217 return s
.encode("utf-16")[2:]
220 return base64
.encodestring(s
).replace("\n", "")
223 for pad
in ["", "=", "==", "A", "A=", "A=="]: # Stupid MSN client!
225 return base64
.decodestring(s
+ pad
)
228 raise ValueError("Got some very bad base64!")
231 format
= "{%4X%4X-%4X-%4X-%4X-%4X%4X%4X}"
234 data
.append(random
.random() * 0xAAFF + 0x1111)
239 def checkParamLen(num
, expected
, cmd
, error
=None):
240 if error
== None: error
= "Invalid Number of Parameters for %s" % cmd
241 if num
!= expected
: raise MSNProtocolError
, error
243 def _parseHeader(h
, v
):
245 Split a certin number of known
246 header values with the format:
247 field1=val,field2=val,field3=val into
248 a dict mapping fields to values.
249 @param h: the header's key
250 @param v: the header's value as a string
253 if h
in ('passporturls','authentication-info','www-authenticate'):
254 v
= v
.replace('Passport1.4','').lstrip()
256 for fieldPair
in v
.split(','):
258 field
,value
= fieldPair
.split('=',1)
259 fields
[field
.lower()] = value
261 fields
[field
.lower()] = ''
265 def _parsePrimitiveHost(host
):
267 h
,p
= host
.replace('https://','').split('/',1)
271 def _login(userHandle
, passwd
, nexusServer
, cached
=0, authData
=''):
273 This function is used internally and should not ever be called
277 def _cb(server
, auth
):
278 loginFac
= ClientFactory()
279 loginFac
.protocol
= lambda : PassportLogin(cb
, userHandle
, passwd
, server
, auth
)
280 reactor
.connectSSL(_parsePrimitiveHost(server
)[0], 443, loginFac
, ClientContextFactory())
283 _cb(nexusServer
, authData
)
285 fac
= ClientFactory()
287 d
.addCallbacks(_cb
, callbackArgs
=(authData
,))
288 d
.addErrback(lambda f
: cb
.errback(f
))
289 fac
.protocol
= lambda : PassportNexus(d
, nexusServer
)
290 reactor
.connectSSL(_parsePrimitiveHost(nexusServer
)[0], 443, fac
, ClientContextFactory())
294 class PassportNexus(HTTPClient
):
297 Used to obtain the URL of a valid passport
300 This class is used internally and should
301 not be instantiated directly -- that is,
302 The passport logging in process is handled
303 transparantly by NotificationClient.
306 def __init__(self
, deferred
, host
):
307 self
.deferred
= deferred
308 self
.host
, self
.path
= _parsePrimitiveHost(host
)
310 def connectionMade(self
):
311 HTTPClient
.connectionMade(self
)
312 self
.sendCommand('GET', self
.path
)
313 self
.sendHeader('Host', self
.host
)
317 def handleHeader(self
, header
, value
):
319 self
.headers
[h
] = _parseHeader(h
, value
)
321 def handleEndHeaders(self
):
322 if self
.connected
: self
.transport
.loseConnection()
323 if not self
.headers
.has_key('passporturls') or not self
.headers
['passporturls'].has_key('dalogin'):
324 self
.deferred
.errback(failure
.Failure(failure
.DefaultException("Invalid Nexus Reply")))
326 self
.deferred
.callback('https://' + self
.headers
['passporturls']['dalogin'])
328 def handleResponse(self
, r
): pass
330 class PassportLogin(HTTPClient
):
332 This class is used internally to obtain
333 a login ticket from a passport HTTPS
334 server -- it should not be used directly.
339 def __init__(self
, deferred
, userHandle
, passwd
, host
, authData
):
340 self
.deferred
= deferred
341 self
.userHandle
= userHandle
343 self
.authData
= authData
344 self
.host
, self
.path
= _parsePrimitiveHost(host
)
346 def connectionMade(self
):
347 self
.sendCommand('GET', self
.path
)
348 self
.sendHeader('Authorization', 'Passport1.4 OrgVerb=GET,OrgURL=http://messenger.msn.com,' +
349 'sign-in=%s,pwd=%s,%s' % (quote(self
.userHandle
), self
.passwd
,self
.authData
))
350 self
.sendHeader('Host', self
.host
)
354 def handleHeader(self
, header
, value
):
356 self
.headers
[h
] = _parseHeader(h
, value
)
358 def handleEndHeaders(self
):
359 if self
._finished
: return
360 self
._finished
= 1 # I think we need this because of HTTPClient
361 if self
.connected
: self
.transport
.loseConnection()
362 authHeader
= 'authentication-info'
363 _interHeader
= 'www-authenticate'
364 if self
.headers
.has_key(_interHeader
): authHeader
= _interHeader
366 info
= self
.headers
[authHeader
]
367 status
= info
['da-status']
368 handler
= getattr(self
, 'login_%s' % (status
,), None)
371 else: raise Exception()
373 self
.deferred
.errback(failure
.Failure(e
))
375 def handleResponse(self
, r
): pass
377 def login_success(self
, info
):
378 ticket
= info
['from-pp']
379 ticket
= ticket
[1:len(ticket
)-1]
380 self
.deferred
.callback((LOGIN_SUCCESS
, ticket
))
382 def login_failed(self
, info
):
383 self
.deferred
.callback((LOGIN_FAILURE
, unquote(info
['cbtxt'])))
385 def login_redir(self
, info
):
386 self
.deferred
.callback((LOGIN_REDIRECT
, self
.headers
['location'], self
.authData
))
388 class MSNProtocolError(Exception):
390 This Exception is basically used for debugging
391 purposes, as the official MSN server should never
392 send anything _wrong_ and nobody in their right
393 mind would run their B{own} MSN server.
394 If it is raised by default command handlers
395 (handle_BLAH) the error will be logged.
402 I am the class used to represent an 'instant' message.
404 @ivar userHandle: The user handle (passport) of the sender
405 (this is only used when receiving a message)
406 @ivar screenName: The screen name of the sender (this is only used
407 when receiving a message)
408 @ivar message: The message
409 @ivar headers: The message headers
411 @ivar length: The message length (including headers and line endings)
412 @ivar ack: This variable is used to tell the server how to respond
413 once the message has been sent. If set to MESSAGE_ACK
414 (default) the server will respond with an ACK upon receiving
415 the message, if set to MESSAGE_NACK the server will respond
416 with a NACK upon failure to receive the message.
417 If set to MESSAGE_ACK_NONE the server will do nothing.
418 This is relevant for the return value of
419 SwitchboardClient.sendMessage (which will return
420 a Deferred if ack is set to either MESSAGE_ACK or MESSAGE_NACK
421 and will fire when the respective ACK or NACK is received).
422 If set to MESSAGE_ACK_NONE sendMessage will return None.
425 MESSAGE_ACK_FAT
= 'D'
427 MESSAGE_ACK_NONE
= 'U'
431 def __init__(self
, length
=0, userHandle
="", screenName
="", message
="", specialMessage
=False):
432 self
.userHandle
= userHandle
433 self
.screenName
= screenName
434 self
.specialMessage
= specialMessage
435 self
.message
= message
436 self
.headers
= {'MIME-Version' : '1.0', 'Content-Type' : 'text/plain'}
440 def _calcMessageLen(self
):
442 used to calculte the number to send
443 as the message length when sending a message.
445 return reduce(operator
.add
, [len(x
[0]) + len(x
[1]) + 4 for x
in self
.headers
.items()]) + len(self
.message
) + 2
447 def setHeader(self
, header
, value
):
448 """ set the desired header """
449 self
.headers
[header
] = value
451 def getHeader(self
, header
):
453 get the desired header value
454 @raise KeyError: if no such header exists.
456 return self
.headers
[header
]
458 def hasHeader(self
, header
):
459 """ check to see if the desired header exists """
460 return self
.headers
.has_key(header
)
462 def getMessage(self
):
463 """ return the message - not including headers """
466 def setMessage(self
, message
):
467 """ set the message text """
468 self
.message
= message
473 Used to represent a MSNObject. This can be currently only be an avatar.
475 @ivar creator: The userHandle of the creator of this picture.
476 @ivar imageData: The PNG image data (only for our own avatar)
477 @ivar type: Always set to 3, for avatar.
478 @ivar size: The size of the image.
479 @ivar location: The filename of the image.
480 @ivar friendly: Unknown.
481 @ivar text: The textual representation of this MSNObject.
483 def __init__(self
, s
=""):
484 """ Pass a XML MSNObject string to parse it, or pass no arguments for a null MSNObject to be created. """
490 def setData(self
, creator
, imageData
):
491 """ Set the creator and imageData for this object """
492 self
.creator
= creator
493 self
.imageData
= imageData
494 self
.size
= len(imageData
)
496 self
.location
= "TMP" + str(random
.randint(1000,9999))
497 self
.friendly
= "AAA="
498 self
.sha1d
= b64enc(sha
.sha(imageData
).digest())
512 """ Makes a textual representation of this MSNObject. Stores it in self.text """
515 h
.append(self
.creator
)
517 h
.append(str(self
.size
))
519 h
.append(str(self
.type))
521 h
.append(self
.location
)
523 h
.append(self
.friendly
)
526 sha1c
= b64enc(sha
.sha("".join(h
)).digest())
527 self
.text
= '<msnobj Creator="%s" Size="%s" Type="%s" Location="%s" Friendly="%s" SHA1D="%s" SHA1C="%s"/>' % (self
.creator
, str(self
.size
), str(self
.type), self
.location
, self
.friendly
, self
.sha1d
, sha1c
)
530 e
= xmlw
.parseText(s
, True)
531 self
.creator
= e
.getAttribute("Creator")
532 self
.size
= int(e
.getAttribute("Size"))
533 self
.type = int(e
.getAttribute("Type"))
534 self
.location
= e
.getAttribute("Location")
535 self
.friendly
= e
.getAttribute("Friendly")
536 self
.sha1d
= e
.getAttribute("SHA1D")
543 This class represents a contact (user).
545 @ivar userGuid: The contact's user guid (unique string)
546 @ivar userHandle: The contact's user handle (passport).
547 @ivar screenName: The contact's screen name.
548 @ivar groups: A list of all the group IDs which this
550 @ivar lists: An integer representing the sum of all lists
551 that this contact belongs to.
552 @ivar caps: int, The capabilities of this client
553 @ivar msnobj: The MSNObject representing the contact's avatar
554 @ivar status: The contact's status code.
555 @type status: str if contact's status is known, None otherwise.
556 @ivar personal: The contact's personal message .
557 @type personal: str if contact's personal message is known, None otherwise.
559 @ivar homePhone: The contact's home phone number.
560 @type homePhone: str if known, otherwise None.
561 @ivar workPhone: The contact's work phone number.
562 @type workPhone: str if known, otherwise None.
563 @ivar mobilePhone: The contact's mobile phone number.
564 @type mobilePhone: str if known, otherwise None.
565 @ivar hasPager: Whether or not this user has a mobile pager
566 @ivar hasBlog: Whether or not this user has a MSN Spaces blog
574 def __init__(self
, userGuid
="", userHandle
="", screenName
="", lists
=0, caps
=0, msnobj
=None, groups
={}, status
=None, personal
=""):
575 self
.userGuid
= userGuid
576 self
.userHandle
= userHandle
577 self
.screenName
= screenName
581 self
.msnobjGot
= True
582 self
.groups
= [] # if applicable
583 self
.status
= status
# current status
584 self
.personal
= personal
587 self
.homePhone
= None
588 self
.workPhone
= None
589 self
.mobilePhone
= None
593 def setPhone(self
, phoneType
, value
):
595 set phone numbers/values for this specific user.
596 for phoneType check the *_PHONE constants and HAS_PAGER
599 t
= phoneType
.upper()
600 if t
== HOME_PHONE
: self
.homePhone
= value
601 elif t
== WORK_PHONE
: self
.workPhone
= value
602 elif t
== MOBILE_PHONE
: self
.mobilePhone
= value
603 elif t
== HAS_PAGER
: self
.hasPager
= value
604 elif t
== HAS_BLOG
: self
.hasBlog
= value
605 #else: raise ValueError, "Invalid Phone Type: " + t
607 def addToList(self
, listType
):
609 Update the lists attribute to
610 reflect being part of the
613 self
.lists |
= listType
615 def removeFromList(self
, listType
):
617 Update the lists attribute to
618 reflect being removed from the
621 self
.lists ^
= listType
623 class MSNContactList
:
625 This class represents a basic MSN contact list.
627 @ivar contacts: All contacts on my various lists
628 @type contacts: dict (mapping user handles to MSNContact objects)
629 @ivar groups: a mapping of group ids to group names
630 (groups can only exist on the forward list)
634 This is used only for storage and doesn't effect the
635 server's contact list.
645 def _getContactsFromList(self
, listType
):
647 Obtain all contacts which belong
648 to the given list type.
650 return dict([(uH
,obj
) for uH
,obj
in self
.contacts
.items() if obj
.lists
& listType
])
652 def addContact(self
, contact
):
656 self
.contacts
[contact
.userHandle
] = contact
658 def remContact(self
, userHandle
):
663 del self
.contacts
[userHandle
]
664 except KeyError: pass
666 def getContact(self
, userHandle
):
668 Obtain the MSNContact object
669 associated with the given
671 @return: the MSNContact object if
672 the user exists, or None.
675 return self
.contacts
[userHandle
]
679 def getBlockedContacts(self
):
681 Obtain all the contacts on my block list
683 return self
._getContactsFromList
(BLOCK_LIST
)
685 def getAuthorizedContacts(self
):
687 Obtain all the contacts on my auth list.
688 (These are contacts which I have verified
689 can view my state changes).
691 return self
._getContactsFromList
(ALLOW_LIST
)
693 def getReverseContacts(self
):
695 Get all contacts on my reverse list.
696 (These are contacts which have added me
697 to their forward list).
699 return self
._getContactsFromList
(REVERSE_LIST
)
701 def getContacts(self
):
703 Get all contacts on my forward list.
704 (These are the contacts which I have added
707 return self
._getContactsFromList
(FORWARD_LIST
)
709 def setGroup(self
, id, name
):
711 Keep a mapping from the given id
714 self
.groups
[id] = name
716 def remGroup(self
, id):
718 Removed the stored group
719 mapping for the given id.
723 except KeyError: pass
724 for c
in self
.contacts
:
725 if id in c
.groups
: c
.groups
.remove(id)
728 class MSNEventBase(LineReceiver
):
730 This class provides support for handling / dispatching events and is the
731 base class of the three main client protocols (DispatchClient,
732 NotificationClient, SwitchboardClient)
736 self
.ids
= {} # mapping of ids to Deferreds
740 self
.currentMessage
= None
742 def connectionLost(self
, reason
):
746 def connectionMade(self
):
749 def _fireCallback(self
, id, *args
):
751 Fire the callback for the given id
752 if one exists and return 1, else return false
754 if self
.ids
.has_key(id):
755 self
.ids
[id][0].callback(args
)
760 def _nextTransactionID(self
):
761 """ return a usable transaction ID """
763 if self
.currentID
> 1000: self
.currentID
= 1
764 return self
.currentID
766 def _createIDMapping(self
, data
=None):
768 return a unique transaction ID that is mapped internally to a
769 deferred .. also store arbitrary data if it is needed
771 id = self
._nextTransactionID
()
773 self
.ids
[id] = (d
, data
)
776 def checkMessage(self
, message
):
778 process received messages to check for file invitations and
779 typing notifications and other control type messages
781 raise NotImplementedError
783 def sendLine(self
, line
):
784 if LINEDEBUG
: log
.msg(">> " + line
)
785 LineReceiver
.sendLine(self
, line
)
787 def lineReceived(self
, line
):
788 if LINEDEBUG
: log
.msg("<< " + line
)
789 if self
.currentMessage
:
790 self
.currentMessage
.readPos
+= len(line
+"\r\n")
792 header
, value
= line
.split(':')
793 self
.currentMessage
.setHeader(header
, unquote(value
).lstrip())
796 #raise MSNProtocolError, "Invalid Message Header"
798 if line
== "" or self
.currentMessage
.specialMessage
:
800 if self
.currentMessage
.readPos
== self
.currentMessage
.length
: self
.rawDataReceived("") # :(
803 cmd
, params
= line
.split(' ', 1)
805 raise MSNProtocolError
, "Invalid Message, %s" % repr(line
)
807 if len(cmd
) != 3: raise MSNProtocolError
, "Invalid Command, %s" % repr(cmd
)
809 if self
.ids
.has_key(params
.split(' ')[0]):
810 self
.ids
[id].errback(int(cmd
))
813 else: # we received an error which doesn't map to a sent command
814 self
.gotError(int(cmd
))
817 handler
= getattr(self
, "handle_%s" % cmd
.upper(), None)
819 try: handler(params
.split(' '))
820 except MSNProtocolError
, why
: self
.gotBadLine(line
, why
)
822 self
.handle_UNKNOWN(cmd
, params
.split(' '))
824 def rawDataReceived(self
, data
):
826 self
.currentMessage
.readPos
+= len(data
)
827 diff
= self
.currentMessage
.readPos
- self
.currentMessage
.length
829 self
.currentMessage
.message
+= data
[:-diff
]
832 self
.currentMessage
.message
+= data
834 self
.currentMessage
.message
+= data
836 del self
.currentMessage
.readPos
837 m
= self
.currentMessage
838 self
.currentMessage
= None
839 if MESSAGEDEBUG
: log
.msg(m
.message
)
841 if not self
.checkMessage(m
):
842 self
.setLineMode(extra
)
845 log
.msg("Traceback - ERROR in checkMessage: " + str(e
))
846 self
.setLineMode(extra
)
849 self
.setLineMode(extra
)
851 ### protocol command handlers - no need to override these.
853 def handle_MSG(self
, params
):
854 checkParamLen(len(params
), 3, 'MSG')
856 messageLen
= int(params
[2])
857 except ValueError: raise MSNProtocolError
, "Invalid Parameter for MSG length argument"
858 self
.currentMessage
= MSNMessage(length
=messageLen
, userHandle
=params
[0], screenName
=unquote(params
[1]))
860 def handle_UNKNOWN(self
, cmd
, params
):
861 """ implement me in subclasses if you want to handle unknown events """
862 log
.msg("Received unknown command (%s), params: %s" % (cmd
, params
))
866 def gotBadLine(self
, line
, why
):
867 """ called when a handler notifies me that this line is broken """
868 log
.msg('Error in line: %s (%s)' % (line
, why
))
870 def gotError(self
, errorCode
):
872 called when the server sends an error which is not in
873 response to a sent command (ie. it has no matching transaction ID)
875 log
.msg('Error %s' % (errorCodes
[errorCode
]))
878 class DispatchClient(MSNEventBase
):
880 This class provides support for clients connecting to the dispatch server
881 @ivar userHandle: your user handle (passport) needed before connecting.
884 def connectionMade(self
):
885 MSNEventBase
.connectionMade(self
)
886 self
.sendLine('VER %s %s' % (self
._nextTransactionID
(), MSN_PROTOCOL_VERSION
))
888 ### protocol command handlers ( there is no need to override these )
890 def handle_VER(self
, params
):
891 versions
= params
[1:]
892 if versions
is None or ' '.join(versions
) != MSN_PROTOCOL_VERSION
:
893 self
.transport
.loseConnection()
894 raise MSNProtocolError
, "Invalid version response"
895 id = self
._nextTransactionID
()
896 self
.sendLine("CVR %s %s %s" % (id, MSN_CVR_STR
, self
.factory
.userHandle
))
898 def handle_CVR(self
, params
):
899 self
.sendLine("USR %s TWN I %s" % (self
._nextTransactionID
(), self
.factory
.userHandle
))
901 def handle_XFR(self
, params
):
902 if len(params
) < 4: raise MSNProtocolError
, "Invalid number of parameters for XFR"
903 id, refType
, addr
= params
[:3]
904 # was addr a host:port pair?
906 host
, port
= addr
.split(':')
911 self
.gotNotificationReferral(host
, int(port
))
915 def gotNotificationReferral(self
, host
, port
):
917 called when we get a referral to the notification server.
919 @param host: the notification server's hostname
920 @param port: the port to connect to
925 class DispatchFactory(ClientFactory
):
927 This class keeps the state for the DispatchClient.
929 @ivar userHandle: the userHandle to request a notification
932 protocol
= DispatchClient
937 class NotificationClient(MSNEventBase
):
939 This class provides support for clients connecting
940 to the notification server.
943 factory
= None # sssh pychecker
945 def __init__(self
, currentID
=0):
946 MSNEventBase
.__init
__(self
)
947 self
.currentID
= currentID
948 self
._state
= ['DISCONNECTED', {}]
950 self
.pingCheckTask
= None
951 self
.msnobj
= MSNObject()
953 def _setState(self
, state
):
954 self
._state
[0] = state
957 return self
._state
[0]
959 def _getStateData(self
, key
):
960 return self
._state
[1][key
]
962 def _setStateData(self
, key
, value
):
963 self
._state
[1][key
] = value
965 def _remStateData(self
, *args
):
966 for key
in args
: del self
._state
[1][key
]
968 def connectionMade(self
):
969 MSNEventBase
.connectionMade(self
)
970 self
._setState
('CONNECTED')
971 self
.sendLine("VER %s %s" % (self
._nextTransactionID
(), MSN_PROTOCOL_VERSION
))
973 def connectionLost(self
, reason
):
974 self
._setState
('DISCONNECTED')
976 if self
.pingCheckTask
:
977 self
.pingCheckTask
.stop()
978 self
.pingCheckTask
= None
979 MSNEventBase
.connectionLost(self
, reason
)
981 def _getEmailFields(self
, message
):
982 fields
= message
.getMessage().strip().split('\n')
986 if len(a
) != 2: continue
993 def _gotInitialEmailNotification(self
, message
):
994 values
= self
._getEmailFields
(message
)
996 inboxunread
= int(values
["Inbox-Unread"])
997 foldersunread
= int(values
["Folders-Unread"])
1000 if foldersunread
+ inboxunread
> 0: # For some reason MSN sends notifications about empty inboxes sometimes?
1001 self
.gotInitialEmailNotification(inboxunread
, foldersunread
)
1003 def _gotEmailNotification(self
, message
):
1004 values
= self
._getEmailFields
(message
)
1006 mailfrom
= values
["From"]
1007 fromaddr
= values
["From-Addr"]
1008 subject
= values
["Subject"]
1009 junkbeginning
= "=?\"us-ascii\"?Q?"
1011 subject
= subject
.replace(junkbeginning
, "").replace(junkend
, "").replace("_", " ")
1013 # If any of the fields weren't found then it's not a big problem. We just ignore the message
1015 self
.gotRealtimeEmailNotification(mailfrom
, fromaddr
, subject
)
1017 def _gotMSNAlert(self
, message
):
1018 notification
= xmlw
.parseText(message
.message
, beExtremelyLenient
=True)
1019 siteurl
= notification
.getAttribute("siteurl")
1020 notid
= notification
.getAttribute("id")
1023 for e
in notification
.elements():
1029 msgid
= msg
.getAttribute("id")
1034 for e
in msg
.elements():
1035 if e
.name
== "ACTION":
1036 action
= e
.getAttribute("url")
1037 if e
.name
== "SUBSCR":
1038 subscr
= e
.getAttribute("url")
1039 if e
.name
== "BODY":
1040 for e2
in e
.elements():
1041 if e2
.name
== "TEXT":
1042 bodytext
= e2
.__str__()
1043 if not (action
and subscr
and bodytext
): return
1045 actionurl
= "%s¬ification_id=%s&message_id=%s&agent=messenger" % (action
, notid
, msgid
) # Used to have $siteurl// at the beginning, but it seems to not work with that now. Weird
1046 subscrurl
= "%s¬ification_id=%s&message_id=%s&agent=messenger" % (subscr
, notid
, msgid
)
1048 self
.gotMSNAlert(bodytext
, actionurl
, subscrurl
)
1050 def _gotUBX(self
, message
):
1051 msnContact
= self
.factory
.contacts
.getContact(message
.userHandle
)
1052 if not msnContact
: return
1053 lm
= message
.message
.lower()
1054 p1
= lm
.find("<psm>") + 5
1055 p2
= lm
.find("</psm>")
1056 if p1
>= 0 and p2
>= 0:
1057 personal
= xmlw
.unescapeFromXml(message
.message
[p1
:p2
])
1058 msnContact
.personal
= personal
1059 self
.contactPersonalChanged(message
.userHandle
, personal
)
1061 msnContact
.personal
= ''
1062 self
.contactPersonalChanged(message
.userHandle
, '')
1064 def checkMessage(self
, message
):
1065 """ hook used for detecting specific notification messages """
1066 cTypes
= [s
.lstrip() for s
in message
.getHeader('Content-Type').split(';')]
1067 if 'text/x-msmsgsprofile' in cTypes
:
1068 self
.gotProfile(message
)
1070 elif "text/x-msmsgsinitialemailnotification" in cTypes
:
1071 self
._gotInitialEmailNotification
(message
)
1073 elif "text/x-msmsgsemailnotification" in cTypes
:
1074 self
._gotEmailNotification
(message
)
1076 elif "NOTIFICATION" == message
.userHandle
and message
.specialMessage
== True:
1077 self
._gotMSNAlert
(message
)
1079 elif "UBX" == message
.screenName
and message
.specialMessage
== True:
1080 self
._gotUBX
(message
)
1084 ### protocol command handlers - no need to override these
1086 def handle_VER(self
, params
):
1087 versions
= params
[1:]
1088 if versions
is None or ' '.join(versions
) != MSN_PROTOCOL_VERSION
:
1089 self
.transport
.loseConnection()
1090 raise MSNProtocolError
, "Invalid version response"
1091 self
.sendLine("CVR %s %s %s" % (self
._nextTransactionID
(), MSN_CVR_STR
, self
.factory
.userHandle
))
1093 def handle_CVR(self
, params
):
1094 self
.sendLine("USR %s TWN I %s" % (self
._nextTransactionID
(), self
.factory
.userHandle
))
1096 def handle_USR(self
, params
):
1097 if not (4 <= len(params
) <= 6):
1098 raise MSNProtocolError
, "Invalid Number of Parameters for USR"
1100 mechanism
= params
[1]
1101 if mechanism
== "OK":
1102 self
.loggedIn(params
[2], int(params
[3]))
1103 elif params
[2].upper() == "S":
1104 # we need to obtain auth from a passport server
1106 d
= _login(f
.userHandle
, f
.password
, f
.passportServer
, authData
=params
[3])
1107 d
.addCallback(self
._passportLogin
)
1108 d
.addErrback(self
._passportError
)
1110 def _passportLogin(self
, result
):
1111 if result
[0] == LOGIN_REDIRECT
:
1112 d
= _login(self
.factory
.userHandle
, self
.factory
.password
,
1113 result
[1], cached
=1, authData
=result
[2])
1114 d
.addCallback(self
._passportLogin
)
1115 d
.addErrback(self
._passportError
)
1116 elif result
[0] == LOGIN_SUCCESS
:
1117 self
.sendLine("USR %s TWN S %s" % (self
._nextTransactionID
(), result
[1]))
1118 elif result
[0] == LOGIN_FAILURE
:
1119 self
.loginFailure(result
[1])
1121 def _passportError(self
, failure
):
1122 self
.loginFailure("Exception while authenticating: %s" % failure
)
1124 def handle_CHG(self
, params
):
1126 if not self
._fireCallback
(id, params
[1]):
1127 if self
.factory
: self
.factory
.status
= params
[1]
1128 self
.statusChanged(params
[1])
1130 def handle_ILN(self
, params
):
1131 #checkParamLen(len(params), 6, 'ILN')
1132 msnContact
= self
.factory
.contacts
.getContact(params
[2])
1133 if not msnContact
: return
1134 msnContact
.status
= params
[1]
1135 msnContact
.screenName
= unquote(params
[3])
1136 if len(params
) > 4: msnContact
.caps
= int(params
[4])
1138 self
.handleAvatarHelper(msnContact
, params
[5])
1140 self
.handleAvatarGoneHelper(msnContact
)
1141 self
.gotContactStatus(params
[2], params
[1], unquote(params
[3]))
1143 def handleAvatarGoneHelper(self
, msnContact
):
1144 if msnContact
.msnobj
:
1145 msnContact
.msnobj
= None
1146 msnContact
.msnobjGot
= True
1147 self
.contactAvatarChanged(msnContact
.userHandle
, "")
1149 def handleAvatarHelper(self
, msnContact
, msnobjStr
):
1150 msnobj
= MSNObject(unquote(msnobjStr
))
1151 if not msnContact
.msnobj
or msnobj
.sha1d
!= msnContact
.msnobj
.sha1d
:
1152 if MSNP2PDEBUG
: log
.msg("Updated MSNObject received!" + msnobjStr
)
1153 msnContact
.msnobj
= msnobj
1154 msnContact
.msnobjGot
= False
1155 self
.contactAvatarChanged(msnContact
.userHandle
, binascii
.hexlify(b64dec(msnContact
.msnobj
.sha1d
)))
1157 def handle_CHL(self
, params
):
1158 checkParamLen(len(params
), 2, 'CHL')
1159 response
= msnp11chl
.doChallenge(params
[1])
1160 self
.sendLine("QRY %s %s %s" % (self
._nextTransactionID
(), msnp11chl
.MSNP11_PRODUCT_ID
, len(response
)))
1161 self
.transport
.write(response
)
1163 def handle_QRY(self
, params
):
1166 def handle_NLN(self
, params
):
1167 if not self
.factory
: return
1168 msnContact
= self
.factory
.contacts
.getContact(params
[1])
1169 if not msnContact
: return
1170 msnContact
.status
= params
[0]
1171 msnContact
.screenName
= unquote(params
[2])
1172 if len(params
) > 3: msnContact
.caps
= int(params
[3])
1174 self
.handleAvatarHelper(msnContact
, params
[4])
1176 self
.handleAvatarGoneHelper(msnContact
)
1177 self
.contactStatusChanged(params
[1], params
[0], unquote(params
[2]))
1179 def handle_FLN(self
, params
):
1180 checkParamLen(len(params
), 1, 'FLN')
1181 msnContact
= self
.factory
.contacts
.getContact(params
[0])
1183 msnContact
.status
= STATUS_OFFLINE
1184 self
.contactOffline(params
[0])
1186 def handle_LST(self
, params
):
1187 if self
._getState
() != 'SYNC': return
1189 userHandle
, screenName
, userGuid
, lists
, groups
= getVals(params
)
1191 if not userHandle
or lists
< 1:
1192 raise MSNProtocolError
, "Unknown LST " + str(params
) # debug
1193 contact
= MSNContact(userGuid
, userHandle
, screenName
, lists
)
1194 if contact
.lists
& FORWARD_LIST
:
1195 contact
.groups
.extend(map(str, groups
))
1196 self
._getStateData
('list').addContact(contact
)
1197 self
._setStateData
('last_contact', contact
)
1198 sofar
= self
._getStateData
('lst_sofar') + 1
1199 if sofar
== self
._getStateData
('lst_reply'):
1200 # this is the best place to determine that
1201 # a syn realy has finished - msn _may_ send
1202 # BPR information for the last contact
1203 # which is unfortunate because it means
1204 # that the real end of a syn is non-deterministic.
1205 # to handle this we'll keep 'last_contact' hanging
1206 # around in the state data and update it if we need
1208 self
._setState
('SESSION')
1209 contacts
= self
._getStateData
('list')
1210 phone
= self
._getStateData
('phone')
1211 id = self
._getStateData
('synid')
1212 self
._remStateData
('lst_reply', 'lsg_reply', 'lst_sofar', 'phone', 'synid', 'list')
1213 self
._fireCallback
(id, contacts
, phone
)
1215 self
._setStateData
('lst_sofar',sofar
)
1217 def handle_BLP(self
, params
):
1218 # check to see if this is in response to a SYN
1219 if self
._getState
() == 'SYNC':
1220 self
._getStateData
('list').privacy
= listCodeToID
[params
[0].lower()]
1223 self
.factory
.contacts
.privacy
= listCodeToID
[params
[1].lower()]
1224 self
._fireCallback
(id, params
[1])
1226 def handle_GTC(self
, params
):
1227 # check to see if this is in response to a SYN
1228 if self
._getState
() == 'SYNC':
1229 if params
[0].lower() == "a": self
._getStateData
('list').autoAdd
= 0
1230 elif params
[0].lower() == "n": self
._getStateData
('list').autoAdd
= 1
1231 else: raise MSNProtocolError
, "Invalid Paramater for GTC" # debug
1234 if params
[1].lower() == "a": self
._fireCallback
(id, 0)
1235 elif params
[1].lower() == "n": self
._fireCallback
(id, 1)
1236 else: raise MSNProtocolError
, "Invalid Paramater for GTC" # debug
1238 def handle_SYN(self
, params
):
1240 self
._setStateData
('phone', []) # Always needs to be set
1241 if params
[3] == 0: # No LST will be received. New account?
1242 self
._setState
('SESSION')
1243 self
._fireCallback
(id, None, None)
1245 contacts
= MSNContactList()
1246 self
._setStateData
('list', contacts
)
1247 self
._setStateData
('lst_reply', int(params
[3]))
1248 self
._setStateData
('lsg_reply', int(params
[4]))
1249 self
._setStateData
('lst_sofar', 0)
1251 def handle_LSG(self
, params
):
1252 if self
._getState
() == 'SYNC':
1253 self
._getStateData
('list').groups
[params
[1]] = unquote(params
[0])
1255 def handle_PRP(self
, params
):
1256 if params
[1] == "MFN":
1257 self
._fireCallback
(int(params
[0]))
1258 elif self
._getState
() == 'SYNC':
1259 self
._getStateData
('phone').append((params
[0], unquote(params
[1])))
1261 self
._fireCallback
(int(params
[0]), int(params
[1]), unquote(params
[3]))
1263 def handle_BPR(self
, params
):
1264 numParams
= len(params
)
1265 if numParams
== 2: # part of a syn
1266 self
._getStateData
('last_contact').setPhone(params
[0], unquote(params
[1]))
1267 elif numParams
== 4:
1268 if not self
.factory
.contacts
: raise MSNProtocolError
, "handle_BPR called with no contact list" # debug
1269 self
.factory
.contacts
.version
= int(params
[0])
1270 userHandle
, phoneType
, number
= params
[1], params
[2], unquote(params
[3])
1271 self
.factory
.contacts
.getContact(userHandle
).setPhone(phoneType
, number
)
1272 self
.gotPhoneNumber(userHandle
, phoneType
, number
)
1275 def handle_ADG(self
, params
):
1276 checkParamLen(len(params
), 5, 'ADG')
1278 if not self
._fireCallback
(id, int(params
[1]), unquote(params
[2]), int(params
[3])):
1279 raise MSNProtocolError
, "ADG response does not match up to a request" # debug
1281 def handle_RMG(self
, params
):
1282 checkParamLen(len(params
), 3, 'RMG')
1284 if not self
._fireCallback
(id, int(params
[1]), int(params
[2])):
1285 raise MSNProtocolError
, "RMG response does not match up to a request" # debug
1287 def handle_REG(self
, params
):
1288 checkParamLen(len(params
), 5, 'REG')
1290 if not self
._fireCallback
(id, int(params
[1]), int(params
[2]), unquote(params
[3])):
1291 raise MSNProtocolError
, "REG response does not match up to a request" # debug
1293 def handle_ADC(self
, params
):
1294 if not self
.factory
.contacts
: raise MSNProtocolError
, "handle_ADC called with no contact list"
1295 numParams
= len(params
)
1296 if numParams
< 3 or params
[1].upper() not in ('AL','BL','RL','FL','PL'):
1297 raise MSNProtocolError
, "Invalid Paramaters for ADC" # debug
1299 listType
= params
[1].lower()
1300 userHandle
, screenName
, userGuid
, ignored1
, groups
= getVals(params
[2:])
1302 if groups
and listType
.upper() != FORWARD_LIST
:
1303 raise MSNProtocolError
, "Only forward list can contain groups" # debug
1305 if not self
._fireCallback
(id, listCodeToID
[listType
], userGuid
, userHandle
, screenName
):
1306 c
= self
.factory
.contacts
.getContact(userHandle
)
1308 c
= MSNContact(userGuid
=userGuid
, userHandle
=userHandle
, screenName
=screenName
)
1309 self
.factory
.contacts
.addContact(c
)
1310 c
.addToList(PENDING_LIST
)
1311 self
.userAddedMe(userGuid
, userHandle
, screenName
)
1313 def handle_REM(self
, params
):
1314 if not self
.factory
.contacts
: raise MSNProtocolError
, "handle_REM called with no contact list available!"
1315 numParams
= len(params
)
1316 if numParams
< 3 or params
[1].upper() not in ('AL','BL','FL','RL','PL'):
1317 raise MSNProtocolError
, "Invalid Paramaters for REM" # debug
1319 listType
= params
[1].lower()
1320 userHandle
= params
[2]
1323 if params
[1] != "FL": raise MSNProtocolError
, "Only forward list can contain groups" # debug
1324 groupID
= int(params
[3])
1325 if not self
._fireCallback
(id, listCodeToID
[listType
], userHandle
, groupID
):
1326 if listType
.upper() != "RL": return
1327 c
= self
.factory
.contacts
.getContact(userHandle
)
1329 c
.removeFromList(REVERSE_LIST
)
1330 if c
.lists
== 0: self
.factory
.contacts
.remContact(c
.userHandle
)
1331 self
.userRemovedMe(userHandle
)
1333 def handle_XFR(self
, params
):
1334 checkParamLen(len(params
), 5, 'XFR')
1336 # check to see if they sent a host/port pair
1338 host
, port
= params
[2].split(':')
1343 if not self
._fireCallback
(id, host
, int(port
), params
[4]):
1344 raise MSNProtocolError
, "Got XFR (referral) that I didn't ask for .. should this happen?" # debug
1346 def handle_RNG(self
, params
):
1347 checkParamLen(len(params
), 6, 'RNG')
1348 # check for host:port pair
1350 host
, port
= params
[1].split(":")
1355 self
.gotSwitchboardInvitation(int(params
[0]), host
, port
, params
[3], params
[4],
1358 def handle_NOT(self
, params
):
1359 checkParamLen(len(params
), 1, 'NOT')
1361 messageLen
= int(params
[0])
1362 except ValueError: raise MSNProtocolError
, "Invalid Parameter for NOT length argument"
1363 self
.currentMessage
= MSNMessage(length
=messageLen
, userHandle
="NOTIFICATION", specialMessage
=True)
1366 def handle_UBX(self
, params
):
1367 checkParamLen(len(params
), 2, 'UBX')
1369 messageLen
= int(params
[1])
1370 except ValueError: raise MSNProtocolError
, "Invalid Parameter for UBX length argument"
1372 self
.currentMessage
= MSNMessage(length
=messageLen
, userHandle
=params
[0], screenName
="UBX", specialMessage
=True)
1375 self
._gotUBX
(MSNMessage(userHandle
=params
[0]))
1377 def handle_UUX(self
, params
):
1378 checkParamLen(len(params
), 2, 'UUX')
1379 if params
[1] != '0': return
1381 self
._fireCallback
(id)
1383 def handle_OUT(self
, params
):
1384 checkParamLen(len(params
), 1, 'OUT')
1385 if params
[0] == "OTH": self
.multipleLogin()
1386 elif params
[0] == "SSD": self
.serverGoingDown()
1387 else: raise MSNProtocolError
, "Invalid Parameters received for OUT" # debug
1389 def handle_QNG(self
, params
):
1390 self
.pingCounter
= 0 # They replied to a ping. We'll forgive them for any they may have missed, because they're alive again now
1394 def pingChecker(self
):
1395 if self
.pingCounter
> 5:
1396 # The server has ignored 5 pings, lets kill the connection
1397 self
.transport
.loseConnection()
1399 self
.sendLine("PNG")
1400 self
.pingCounter
+= 1
1402 def pingCheckerStart(self
, *args
):
1403 self
.pingCheckTask
= task
.LoopingCall(self
.pingChecker
)
1404 self
.pingCheckTask
.start(PINGSPEED
)
1406 def loggedIn(self
, userHandle
, verified
):
1408 Called when the client has logged in.
1409 The default behaviour of this method is to
1410 update the factory with our screenName and
1411 to sync the contact list (factory.contacts).
1412 When this is complete self.listSynchronized
1415 @param userHandle: our userHandle
1416 @param verified: 1 if our passport has been (verified), 0 if not.
1417 (i'm not sure of the significace of this)
1421 d
.addCallback(self
.listSynchronized
)
1422 d
.addCallback(self
.pingCheckerStart
)
1424 def loginFailure(self
, message
):
1426 Called when the client fails to login.
1428 @param message: a message indicating the problem that was encountered
1432 def gotProfile(self
, message
):
1434 Called after logging in when the server sends an initial
1435 message with MSN/passport specific profile information
1436 such as country, number of kids, etc.
1437 Check the message headers for the specific values.
1439 @param message: The profile message
1443 def listSynchronized(self
, *args
):
1445 Lists are now synchronized by default upon logging in, this
1446 method is called after the synchronization has finished
1447 and the factory now has the up-to-date contacts.
1451 def contactAvatarChanged(self
, userHandle
, hash):
1453 Called when we receive the first, or a new <msnobj/> from a
1456 @param userHandle: contact who's msnobj has been changed
1457 @param hash: sha1 hash of their avatar as hex string
1460 def statusChanged(self
, statusCode
):
1462 Called when our status changes and its not in response to a
1465 @param statusCode: 3-letter status code
1469 def gotContactStatus(self
, userHandle
, statusCode
, screenName
):
1471 Called when we receive a list of statuses upon login.
1473 @param userHandle: the contact's user handle (passport)
1474 @param statusCode: 3-letter status code
1475 @param screenName: the contact's screen name
1479 def contactStatusChanged(self
, userHandle
, statusCode
, screenName
):
1481 Called when we're notified that a contact's status has changed.
1483 @param userHandle: the contact's user handle (passport)
1484 @param statusCode: 3-letter status code
1485 @param screenName: the contact's screen name
1489 def contactPersonalChanged(self
, userHandle
, personal
):
1491 Called when a contact's personal message changes.
1493 @param userHandle: the contact who changed their personal message
1494 @param personal : the new personal message
1498 def contactOffline(self
, userHandle
):
1500 Called when a contact goes offline.
1502 @param userHandle: the contact's user handle
1506 def gotMessage(self
, message
):
1508 Called when there is a message from the notification server
1509 that is not understood by default.
1511 @param message: the MSNMessage.
1515 def gotMSNAlert(self
, body
, action
, subscr
):
1517 Called when the server sends an MSN Alert (http://alerts.msn.com)
1519 @param body : the alert text
1520 @param action: a URL with more information for the user to view
1521 @param subscr: a URL the user can use to modify their alert subscription
1525 def gotInitialEmailNotification(self
, inboxunread
, foldersunread
):
1527 Called when the server sends you details about your hotmail
1528 inbox. This is only ever called once, on login.
1530 @param inboxunread : the number of unread items in your inbox
1531 @param foldersunread: the number of unread items in other folders
1535 def gotRealtimeEmailNotification(self
, mailfrom
, fromaddr
, subject
):
1537 Called when the server sends us realtime email
1538 notification. This means that you have received
1539 a new email in your hotmail inbox.
1541 @param mailfrom: the sender of the email
1542 @param fromaddr: the sender of the email (I don't know :P)
1543 @param subject : the email subject
1547 def gotPhoneNumber(self
, userHandle
, phoneType
, number
):
1549 Called when the server sends us phone details about
1550 a specific user (for example after a user is added
1551 the server will send their status, phone details etc.
1553 @param userHandle: the contact's user handle (passport)
1554 @param phoneType: the specific phoneType
1555 (*_PHONE constants or HAS_PAGER)
1556 @param number: the value/phone number.
1560 def userAddedMe(self
, userGuid
, userHandle
, screenName
):
1562 Called when a user adds me to their list. (ie. they have been added to
1565 @param userHandle: the userHandle of the user
1566 @param screenName: the screen name of the user
1570 def userRemovedMe(self
, userHandle
):
1572 Called when a user removes us from their contact list
1573 (they are no longer on our reverseContacts list.
1575 @param userHandle: the contact's user handle (passport)
1579 def gotSwitchboardInvitation(self
, sessionID
, host
, port
,
1580 key
, userHandle
, screenName
):
1582 Called when we get an invitation to a switchboard server.
1583 This happens when a user requests a chat session with us.
1585 @param sessionID: session ID number, must be remembered for logging in
1586 @param host: the hostname of the switchboard server
1587 @param port: the port to connect to
1588 @param key: used for authorization when connecting
1589 @param userHandle: the user handle of the person who invited us
1590 @param screenName: the screen name of the person who invited us
1594 def multipleLogin(self
):
1596 Called when the server says there has been another login
1597 under our account, the server should disconnect us right away.
1601 def serverGoingDown(self
):
1603 Called when the server has notified us that it is going down for
1610 def changeStatus(self
, status
):
1612 Change my current status. This method will add
1613 a default callback to the returned Deferred
1614 which will update the status attribute of the
1617 @param status: 3-letter status code (as defined by
1618 the STATUS_* constants)
1619 @return: A Deferred, the callback of which will be
1620 fired when the server confirms the change
1621 of status. The callback argument will be
1622 a tuple with the new status code as the
1626 id, d
= self
._createIDMapping
()
1627 self
.sendLine("CHG %s %s %s %s" % (id, status
, str(MSNContact
.MSNC1 | MSNContact
.MSNC2 | MSNContact
.MSNC3 | MSNContact
.MSNC4
), quote(self
.msnobj
.text
)))
1629 self
.factory
.status
= r
[0]
1631 return d
.addCallback(_cb
)
1633 def setPrivacyMode(self
, privLevel
):
1635 Set my privacy mode on the server.
1638 This only keeps the current privacy setting on
1639 the server for later retrieval, it does not
1640 effect the way the server works at all.
1642 @param privLevel: This parameter can be true, in which
1643 case the server will keep the state as
1644 'al' which the official client interprets
1645 as -> allow messages from only users on
1646 the allow list. Alternatively it can be
1647 false, in which case the server will keep
1648 the state as 'bl' which the official client
1649 interprets as -> allow messages from all
1650 users except those on the block list.
1652 @return: A Deferred, the callback of which will be fired when
1653 the server replies with the new privacy setting.
1654 The callback argument will be a tuple, the only element
1655 of which being either 'al' or 'bl' (the new privacy setting).
1658 id, d
= self
._createIDMapping
()
1659 if privLevel
: self
.sendLine("BLP %s AL" % id)
1660 else: self
.sendLine("BLP %s BL" % id)
1665 Used for keeping an up-to-date contact list.
1666 A callback is added to the returned Deferred
1667 that updates the contact list on the factory
1668 and also sets my state to STATUS_ONLINE.
1671 This is called automatically upon signing
1672 in using the version attribute of
1673 factory.contacts, so you may want to persist
1674 this object accordingly. Because of this there
1675 is no real need to ever call this method
1678 @return: A Deferred, the callback of which will be
1679 fired when the server sends an adequate reply.
1680 The callback argument will be a tuple with two
1681 elements, the new list (MSNContactList) and
1682 your current state (a dictionary). If the version
1683 you sent _was_ the latest list version, both elements
1684 will be None. To just request the list send a version of 0.
1687 self
._setState
('SYNC')
1688 id, d
= self
._createIDMapping
(data
=None)
1689 self
._setStateData
('synid',id)
1690 self
.sendLine("SYN %s %s %s" % (id, 0, 0))
1692 self
.changeStatus(STATUS_ONLINE
)
1693 if r
[0] is not None:
1694 self
.factory
.contacts
= r
[0]
1696 return d
.addCallback(_cb
)
1698 def setPhoneDetails(self
, phoneType
, value
):
1700 Set/change my phone numbers stored on the server.
1702 @param phoneType: phoneType can be one of the following
1703 constants - HOME_PHONE, WORK_PHONE,
1704 MOBILE_PHONE, HAS_PAGER.
1705 These are pretty self-explanatory, except
1706 maybe HAS_PAGER which refers to whether or
1707 not you have a pager.
1708 @param value: for all of the *_PHONE constants the value is a
1709 phone number (str), for HAS_PAGER accepted values
1710 are 'Y' (for yes) and 'N' (for no).
1712 @return: A Deferred, the callback for which will be fired when
1713 the server confirms the change has been made. The
1714 callback argument will be a tuple with 2 elements, the
1715 first being the new list version (int) and the second
1716 being the new phone number value (str).
1718 raise "ProbablyDoesntWork"
1719 # XXX: Add a default callback which updates
1720 # factory.contacts.version and the relevant phone
1722 id, d
= self
._createIDMapping
()
1723 self
.sendLine("PRP %s %s %s" % (id, phoneType
, quote(value
)))
1726 def addListGroup(self
, name
):
1728 Used to create a new list group.
1729 A default callback is added to the
1730 returned Deferred which updates the
1731 contacts attribute of the factory.
1733 @param name: The desired name of the new group.
1735 @return: A Deferred, the callbacck for which will be called
1736 when the server clarifies that the new group has been
1737 created. The callback argument will be a tuple with 3
1738 elements: the new list version (int), the new group name
1739 (str) and the new group ID (int).
1742 raise "ProbablyDoesntWork"
1743 id, d
= self
._createIDMapping
()
1744 self
.sendLine("ADG %s %s 0" % (id, quote(name
)))
1746 if self
.factory
.contacts
:
1747 self
.factory
.contacts
.version
= r
[0]
1748 self
.factory
.contacts
.setGroup(r
[1], r
[2])
1750 return d
.addCallback(_cb
)
1752 def remListGroup(self
, groupID
):
1754 Used to remove a list group.
1755 A default callback is added to the
1756 returned Deferred which updates the
1757 contacts attribute of the factory.
1759 @param groupID: the ID of the desired group to be removed.
1761 @return: A Deferred, the callback for which will be called when
1762 the server clarifies the deletion of the group.
1763 The callback argument will be a tuple with 2 elements:
1764 the new list version (int) and the group ID (int) of
1768 raise "ProbablyDoesntWork"
1769 id, d
= self
._createIDMapping
()
1770 self
.sendLine("RMG %s %s" % (id, groupID
))
1772 self
.factory
.contacts
.version
= r
[0]
1773 self
.factory
.contacts
.remGroup(r
[1])
1775 return d
.addCallback(_cb
)
1777 def renameListGroup(self
, groupID
, newName
):
1779 Used to rename an existing list group.
1780 A default callback is added to the returned
1781 Deferred which updates the contacts attribute
1784 @param groupID: the ID of the desired group to rename.
1785 @param newName: the desired new name for the group.
1787 @return: A Deferred, the callback for which will be called
1788 when the server clarifies the renaming.
1789 The callback argument will be a tuple of 3 elements,
1790 the new list version (int), the group id (int) and
1791 the new group name (str).
1794 raise "ProbablyDoesntWork"
1795 id, d
= self
._createIDMapping
()
1796 self
.sendLine("REG %s %s %s 0" % (id, groupID
, quote(newName
)))
1798 self
.factory
.contacts
.version
= r
[0]
1799 self
.factory
.contacts
.setGroup(r
[1], r
[2])
1801 return d
.addCallback(_cb
)
1803 def addContact(self
, listType
, userHandle
):
1805 Used to add a contact to the desired list.
1806 A default callback is added to the returned
1807 Deferred which updates the contacts attribute of
1808 the factory with the new contact information.
1809 If you are adding a contact to the forward list
1810 and you want to associate this contact with multiple
1811 groups then you will need to call this method for each
1812 group you would like to add them to, changing the groupID
1813 parameter. The default callback will take care of updating
1814 the group information on the factory's contact list.
1816 @param listType: (as defined by the *_LIST constants)
1817 @param userHandle: the user handle (passport) of the contact
1820 @return: A Deferred, the callback for which will be called when
1821 the server has clarified that the user has been added.
1822 The callback argument will be a tuple with 4 elements:
1823 the list type, the contact's user handle, the new list
1824 version, and the group id (if relevant, otherwise it
1828 id, d
= self
._createIDMapping
()
1829 try: # Make sure the contact isn't actually on the list
1830 if self
.factory
.contacts
.getContact(userHandle
).lists
& listType
: return
1831 except AttributeError: pass
1832 listType
= listIDToCode
[listType
].upper()
1833 if listType
== "FL":
1834 self
.sendLine("ADC %s %s N=%s F=%s" % (id, listType
, userHandle
, userHandle
))
1836 self
.sendLine("ADC %s %s N=%s" % (id, listType
, userHandle
))
1839 if not self
.factory
: return
1840 c
= self
.factory
.contacts
.getContact(r
[2])
1842 c
= MSNContact(userGuid
=r
[1], userHandle
=r
[2], screenName
=r
[3])
1843 self
.factory
.contacts
.addContact(c
)
1844 #if r[3]: c.groups.append(r[3])
1847 return d
.addCallback(_cb
)
1849 def remContact(self
, listType
, userHandle
):
1851 Used to remove a contact from the desired list.
1852 A default callback is added to the returned deferred
1853 which updates the contacts attribute of the factory
1854 to reflect the new contact information.
1856 @param listType: (as defined by the *_LIST constants)
1857 @param userHandle: the user handle (passport) of the
1858 contact being removed
1860 @return: A Deferred, the callback for which will be called when
1861 the server has clarified that the user has been removed.
1862 The callback argument will be a tuple of 3 elements:
1863 the list type, the contact's user handle and the group ID
1864 (if relevant, otherwise it will be None)
1867 id, d
= self
._createIDMapping
()
1868 try: # Make sure the contact is actually on this list
1869 if not (self
.factory
.contacts
.getContact(userHandle
).lists
& listType
): return
1870 except AttributeError: return
1871 listType
= listIDToCode
[listType
].upper()
1872 if listType
== "FL":
1874 c
= self
.factory
.contacts
.getContact(userHandle
)
1875 userGuid
= c
.userGuid
1876 except AttributeError: return
1877 self
.sendLine("REM %s FL %s" % (id, userGuid
))
1879 self
.sendLine("REM %s %s %s" % (id, listType
, userHandle
))
1882 if listType
== "FL":
1883 r
= (r
[0], userHandle
, r
[2]) # make sure we always get a userHandle
1884 l
= self
.factory
.contacts
1885 c
= l
.getContact(r
[1])
1889 if group
: # they may not have been removed from the list
1890 c
.groups
.remove(group
)
1891 if c
.groups
: shouldRemove
= 0
1893 c
.removeFromList(r
[0])
1894 if c
.lists
== 0: l
.remContact(c
.userHandle
)
1896 return d
.addCallback(_cb
)
1898 def changeScreenName(self
, newName
):
1900 Used to change your current screen name.
1901 A default callback is added to the returned
1902 Deferred which updates the screenName attribute
1903 of the factory and also updates the contact list
1906 @param newName: the new screen name
1908 @return: A Deferred, the callback for which will be called
1909 when the server acknowledges the change.
1910 The callback argument will be an empty tuple.
1913 id, d
= self
._createIDMapping
()
1914 self
.sendLine("PRP %s MFN %s" % (id, quote(newName
)))
1916 self
.factory
.screenName
= newName
1918 return d
.addCallback(_cb
)
1920 def changePersonalMessage(self
, personal
):
1922 Used to change your personal message.
1924 @param personal: the new screen name
1926 @return: A Deferred, the callback for which will be called
1927 when the server acknowledges the change.
1928 The callback argument will be a tuple of 1 element,
1929 the personal message.
1932 id, d
= self
._createIDMapping
()
1935 data
= "<Data><PSM>" + personal
+ "</PSM><CurrentMedia></CurrentMedia></Data>"
1936 self
.sendLine("UUX %s %s" % (id, len(data
)))
1937 self
.transport
.write(data
)
1939 self
.factory
.personal
= personal
1941 return d
.addCallback(_cb
)
1943 def changeAvatar(self
, imageData
, push
):
1945 Used to change the avatar that other users see.
1947 @param imageData: the PNG image data to set as the avatar
1948 @param push : whether to push the update to the server
1949 (it will otherwise be sent with the next
1952 @return: If push==True, a Deferred, the callback for which
1953 will be called when the server acknowledges the change.
1954 The callback argument will be the same as for changeStatus.
1957 if self
.msnobj
and imageData
== self
.msnobj
.imageData
: return
1959 self
.msnobj
.setData(self
.factory
.userHandle
, imageData
)
1961 self
.msnobj
.setNull()
1962 if push
: return self
.changeStatus(self
.factory
.status
) # Push to server
1965 def requestSwitchboardServer(self
):
1967 Used to request a switchboard server to use for conversations.
1969 @return: A Deferred, the callback for which will be called when
1970 the server responds with the switchboard information.
1971 The callback argument will be a tuple with 3 elements:
1972 the host of the switchboard server, the port and a key
1973 used for logging in.
1976 id, d
= self
._createIDMapping
()
1977 self
.sendLine("XFR %s SB" % id)
1982 Used to log out of the notification server.
1983 After running the method the server is expected
1984 to close the connection.
1987 if self
.pingCheckTask
:
1988 self
.pingCheckTask
.stop()
1989 self
.pingCheckTask
= None
1990 self
.sendLine("OUT")
1991 self
.transport
.loseConnection()
1993 class NotificationFactory(ClientFactory
):
1995 Factory for the NotificationClient protocol.
1996 This is basically responsible for keeping
1997 the state of the client and thus should be used
1998 in a 1:1 situation with clients.
2000 @ivar contacts: An MSNContactList instance reflecting
2001 the current contact list -- this is
2002 generally kept up to date by the default
2004 @ivar userHandle: The client's userHandle, this is expected
2005 to be set by the client and is used by the
2006 protocol (for logging in etc).
2007 @ivar screenName: The client's current screen-name -- this is
2008 generally kept up to date by the default
2010 @ivar password: The client's password -- this is (obviously)
2011 expected to be set by the client.
2012 @ivar passportServer: This must point to an msn passport server
2013 (the whole URL is required)
2014 @ivar status: The status of the client -- this is generally kept
2015 up to date by the default command handlers
2022 passportServer
= 'https://nexus.passport.com/rdr/pprdr.asp'
2024 protocol
= NotificationClient
2027 class SwitchboardClient(MSNEventBase
):
2029 This class provides support for clients connecting to a switchboard server.
2031 Switchboard servers are used for conversations with other people
2032 on the MSN network. This means that the number of conversations at
2033 any given time will be directly proportional to the number of
2034 connections to varioius switchboard servers.
2036 MSN makes no distinction between single and group conversations,
2037 so any number of users may be invited to join a specific conversation
2038 taking place on a switchboard server.
2040 @ivar key: authorization key, obtained when receiving
2041 invitation / requesting switchboard server.
2042 @ivar userHandle: your user handle (passport)
2043 @ivar sessionID: unique session ID, used if you are replying
2044 to a switchboard invitation
2045 @ivar reply: set this to 1 in connectionMade or before to signifiy
2046 that you are replying to a switchboard invitation.
2047 @ivar msnobj: the MSNObject for the user's avatar. So that the
2048 switchboard can distribute it to anyone who asks.
2060 MSNEventBase
.__init
__(self
)
2061 self
.pendingUsers
= {}
2062 self
.cookies
= {'iCookies' : {}} # will maybe be moved to a factory in the future
2065 def connectionMade(self
):
2066 MSNEventBase
.connectionMade(self
)
2069 def connectionLost(self
, reason
):
2070 self
.cookies
['iCookies'] = {}
2071 MSNEventBase
.connectionLost(self
, reason
)
2073 def _sendInit(self
):
2075 send initial data based on whether we are replying to an invitation
2078 id = self
._nextTransactionID
()
2080 self
.sendLine("USR %s %s %s" % (id, self
.userHandle
, self
.key
))
2082 self
.sendLine("ANS %s %s %s %s" % (id, self
.userHandle
, self
.key
, self
.sessionID
))
2084 def _newInvitationCookie(self
):
2086 if self
._iCookie
> 1000: self
._iCookie
= 1
2087 return self
._iCookie
2089 def _checkTyping(self
, message
, cTypes
):
2090 """ helper method for checkMessage """
2091 if 'text/x-msmsgscontrol' in cTypes
and message
.hasHeader('TypingUser'):
2092 self
.gotContactTyping(message
)
2095 def _checkFileInvitation(self
, message
, info
):
2096 """ helper method for checkMessage """
2097 if not info
.get('Application-GUID', '').upper() == MSN_MSNFTP_GUID
: return 0
2099 cookie
= info
['Invitation-Cookie']
2100 filename
= info
['Application-File']
2101 filesize
= int(info
['Application-FileSize'])
2102 connectivity
= (info
.get('Connectivity', 'n').lower() == 'y')
2104 log
.msg('Received munged file transfer request ... ignoring.')
2106 raise NotImplementedError
2107 self
.gotSendRequest(msnft
.MSNFTP_Receive(filename
, filesize
, message
.userHandle
, cookie
, connectivity
, self
))
2110 def _handleP2PMessage(self
, message
):
2111 """ helper method for msnslp messages (file transfer & avatars) """
2112 if not message
.getHeader("P2P-Dest") == self
.userHandle
: return
2113 packet
= message
.message
2114 binaryFields
= BinaryFields(packet
=packet
)
2115 if binaryFields
[0] != 0:
2116 slpLink
= self
.slpLinks
.get(binaryFields
[0])
2118 # Link has been killed. Ignore
2120 if slpLink
.remoteUser
== message
.userHandle
:
2121 slpLink
.handlePacket(packet
)
2122 if binaryFields
[5] == BinaryFields
.ACK
or binaryFields
[5] == BinaryFields
.BYEGOT
:
2123 pass # Ignore the ACKs to SLP messages
2125 slpMessage
= MSNSLPMessage(packet
)
2127 # Always try and give a slpMessage to a slpLink first.
2128 # If none can be found, and it was INVITE, then create
2129 # one to handle the session.
2130 for slpLink
in self
.slpLinks
.values():
2131 if slpLink
.sessionGuid
== slpMessage
.sessionGuid
:
2132 slpLink
.handleSLPMessage(slpMessage
)
2135 slpLink
= None # Was not handled
2137 if not slpLink
and slpMessage
.method
== "INVITE":
2138 if slpMessage
.euf_guid
== MSN_MSNFTP_GUID
:
2139 context
= FileContext(slpMessage
.context
)
2140 slpLink
= SLPLink_FileReceive(remoteUser
=slpMessage
.fro
, switchboard
=self
, filename
=context
.filename
, filesize
=context
.filesize
, sessionID
=slpMessage
.sessionID
, sessionGuid
=slpMessage
.sessionGuid
, branch
=slpMessage
.branch
)
2141 self
.slpLinks
[slpMessage
.sessionID
] = slpLink
2142 self
.gotFileReceive(slpLink
)
2143 elif slpMessage
.euf_guid
== MSN_AVATAR_GUID
:
2144 # Check that we have an avatar to send
2146 slpLink
= SLPLink_AvatarSend(remoteUser
=slpMessage
.fro
, switchboard
=self
, filesize
=self
.msnobj
.size
, sessionID
=slpMessage
.sessionID
, sessionGuid
=slpMessage
.sessionGuid
)
2147 slpLink
.write(self
.msnobj
.imageData
)
2150 # They shouldn't have sent a request if we have
2151 # no avatar. So we'll just ignore them.
2152 # FIXME We should really send an error
2155 self
.slpLinks
[slpMessage
.sessionID
] = slpLink
2157 # Always need to ACK these packets if we can
2158 slpLink
.sendP2PACK(binaryFields
)
2161 def checkMessage(self
, message
):
2163 hook for detecting any notification type messages
2164 (e.g. file transfer)
2166 cTypes
= [s
.lstrip() for s
in message
.getHeader('Content-Type').split(';')]
2167 if self
._checkTyping
(message
, cTypes
): return 0
2168 if 'text/x-msmsgsinvite' in cTypes
:
2169 # header like info is sent as part of the message body.
2171 for line
in message
.message
.split('\r\n'):
2173 key
, val
= line
.split(':')
2174 info
[key
] = val
.lstrip()
2175 except ValueError: continue
2176 if self
._checkFileInvitation
(message
, info
): return 0
2177 elif 'application/x-msnmsgrp2p' in cTypes
:
2178 self
._handleP
2PMessage
(message
)
2183 def handle_USR(self
, params
):
2184 checkParamLen(len(params
), 4, 'USR')
2185 if params
[1] == "OK":
2189 def handle_CAL(self
, params
):
2190 checkParamLen(len(params
), 3, 'CAL')
2192 if params
[1].upper() == "RINGING":
2193 self
._fireCallback
(id, int(params
[2])) # session ID as parameter
2196 def handle_JOI(self
, params
):
2197 checkParamLen(len(params
), 2, 'JOI')
2198 self
.userJoined(params
[0], unquote(params
[1]))
2200 # users participating in the current chat
2201 def handle_IRO(self
, params
):
2202 checkParamLen(len(params
), 5, 'IRO')
2203 self
.pendingUsers
[params
[3]] = unquote(params
[4])
2204 if params
[1] == params
[2]:
2205 self
.gotChattingUsers(self
.pendingUsers
)
2206 self
.pendingUsers
= {}
2208 # finished listing users
2209 def handle_ANS(self
, params
):
2210 checkParamLen(len(params
), 2, 'ANS')
2211 if params
[1] == "OK":
2214 def handle_ACK(self
, params
):
2215 checkParamLen(len(params
), 1, 'ACK')
2216 self
._fireCallback
(int(params
[0]), None)
2218 def handle_NAK(self
, params
):
2219 checkParamLen(len(params
), 1, 'NAK')
2220 self
._fireCallback
(int(params
[0]), None)
2222 def handle_BYE(self
, params
):
2223 #checkParamLen(len(params), 1, 'BYE') # i've seen more than 1 param passed to this
2224 self
.userLeft(params
[0])
2230 called when all login details have been negotiated.
2231 Messages can now be sent, or new users invited.
2235 def gotChattingUsers(self
, users
):
2237 called after connecting to an existing chat session.
2239 @param users: A dict mapping user handles to screen names
2240 (current users taking part in the conversation)
2244 def userJoined(self
, userHandle
, screenName
):
2246 called when a user has joined the conversation.
2248 @param userHandle: the user handle (passport) of the user
2249 @param screenName: the screen name of the user
2253 def userLeft(self
, userHandle
):
2255 called when a user has left the conversation.
2257 @param userHandle: the user handle (passport) of the user.
2261 def gotMessage(self
, message
):
2263 called when we receive a message.
2265 @param message: the associated MSNMessage object
2269 def gotFileReceive(self
, fileReceive
):
2271 called when we receive a file send request from a contact.
2272 Default action is to reject the file.
2274 @param fileReceive: msnft.MSNFTReceive_Base instance
2276 fileReceive
.reject()
2279 def gotSendRequest(self
, fileReceive
):
2281 called when we receive a file send request from a contact
2283 @param fileReceive: msnft.MSNFTReceive_Base instance
2287 def gotContactTyping(self
, message
):
2289 called when we receive the special type of message notifying
2290 us that a contact is typing a message.
2292 @param message: the associated MSNMessage object
2298 def inviteUser(self
, userHandle
):
2300 used to invite a user to the current switchboard server.
2302 @param userHandle: the user handle (passport) of the desired user.
2304 @return: A Deferred, the callback for which will be called
2305 when the server notifies us that the user has indeed
2306 been invited. The callback argument will be a tuple
2307 with 1 element, the sessionID given to the invited user.
2308 I'm not sure if this is useful or not.
2311 id, d
= self
._createIDMapping
()
2312 self
.sendLine("CAL %s %s" % (id, userHandle
))
2315 def sendMessage(self
, message
):
2317 used to send a message.
2319 @param message: the corresponding MSNMessage object.
2321 @return: Depending on the value of message.ack.
2322 If set to MSNMessage.MESSAGE_ACK or
2323 MSNMessage.MESSAGE_NACK a Deferred will be returned,
2324 the callback for which will be fired when an ACK or
2325 NACK is received - the callback argument will be
2326 (None,). If set to MSNMessage.MESSAGE_ACK_NONE then
2327 the return value is None.
2330 if message
.ack
not in ('A','N','D'): id, d
= self
._nextTransactionID
(), None
2331 else: id, d
= self
._createIDMapping
()
2332 if message
.length
== 0: message
.length
= message
._calcMessageLen
()
2333 self
.sendLine("MSG %s %s %s" % (id, message
.ack
, message
.length
))
2334 # apparently order matters with at least MIME-Version and Content-Type
2335 self
.sendLine('MIME-Version: %s' % message
.getHeader('MIME-Version'))
2336 self
.sendLine('Content-Type: %s' % message
.getHeader('Content-Type'))
2337 # send the rest of the headers
2338 for header
in [h
for h
in message
.headers
.items() if h
[0].lower() not in ('mime-version','content-type')]:
2339 self
.sendLine("%s: %s" % (header
[0], header
[1]))
2340 self
.transport
.write("\r\n")
2341 self
.transport
.write(message
.message
)
2342 if MESSAGEDEBUG
: log
.msg(message
.message
)
2345 def sendAvatarRequest(self
, msnContact
):
2347 used to request an avatar from a user in this switchboard
2350 @param msnContact: the msnContact object to request an avatar for
2352 @return: A Deferred, the callback for which will be called
2353 when the avatar transfer succeeds.
2354 The callback argument will be a tuple with one element,
2355 the PNG avatar data.
2357 if not msnContact
.msnobj
: return
2359 def bufferClosed(data
):
2361 buffer = StringBuffer(bufferClosed
)
2362 slpLink
= SLPLink_AvatarReceive(remoteUser
=msnContact
.userHandle
, switchboard
=self
, consumer
=buffer, context
=msnContact
.msnobj
.text
)
2363 self
.slpLinks
[slpLink
.sessionID
] = slpLink
2366 def sendFile(self
, msnContact
, filename
, filesize
):
2368 used to send a file to a contact.
2370 @param msnContact: the MSNContact object to send a file to.
2371 @param filename: the name of the file to send.
2372 @param filesize: the size of the file to send.
2374 @return: (fileSend, d) A FileSend object and a Deferred.
2375 The Deferred will pass one argument in a tuple,
2376 whether or not the transfer is accepted. If you
2377 receive a True, then you can call write() on the
2378 fileSend object to send your file. Call close()
2379 when the file is done.
2380 NOTE: You MUST write() exactly as much as you
2381 declare in filesize.
2383 if not msnContact
.userHandle
: return
2384 # FIXME, check msnContact.caps to see if we should use old-style
2385 fileSend
= SLPLink_FileSend(remoteUser
=msnContact
.userHandle
, switchboard
=self
, filename
=filename
, filesize
=filesize
)
2386 self
.slpLinks
[fileSend
.sessionID
] = fileSend
2387 return fileSend
, fileSend
.acceptDeferred
2389 def sendTypingNotification(self
):
2391 Used to send a typing notification. Upon receiving this
2392 message the official client will display a 'user is typing'
2393 message to all other users in the chat session for 10 seconds.
2394 You should send one of these every 5 seconds as long as the
2398 m
.ack
= m
.MESSAGE_ACK_NONE
2399 m
.setHeader('Content-Type', 'text/x-msmsgscontrol')
2400 m
.setHeader('TypingUser', self
.userHandle
)
2404 def sendFileInvitation(self
, fileName
, fileSize
):
2406 send an notification that we want to send a file.
2408 @param fileName: the file name
2409 @param fileSize: the file size
2411 @return: A Deferred, the callback of which will be fired
2412 when the user responds to this invitation with an
2413 appropriate message. The callback argument will be
2414 a tuple with 3 elements, the first being 1 or 0
2415 depending on whether they accepted the transfer
2416 (1=yes, 0=no), the second being an invitation cookie
2417 to identify your follow-up responses and the third being
2418 the message 'info' which is a dict of information they
2419 sent in their reply (this doesn't really need to be used).
2420 If you wish to proceed with the transfer see the
2421 sendTransferInfo method.
2423 cookie
= self
._newInvitationCookie
()
2426 m
.setHeader('Content-Type', 'text/x-msmsgsinvite; charset=UTF-8')
2427 m
.message
+= 'Application-Name: File Transfer\r\n'
2428 m
.message
+= 'Application-GUID: %s\r\n' % MSN_MSNFTP_GUID
2429 m
.message
+= 'Invitation-Command: INVITE\r\n'
2430 m
.message
+= 'Invitation-Cookie: %s\r\n' % str(cookie
)
2431 m
.message
+= 'Application-File: %s\r\n' % fileName
2432 m
.message
+= 'Application-FileSize: %s\r\n\r\n' % str(fileSize
)
2433 m
.ack
= m
.MESSAGE_ACK_NONE
2435 self
.cookies
['iCookies'][cookie
] = (d
, m
)
2438 def sendTransferInfo(self
, accept
, iCookie
, authCookie
, ip
, port
):
2440 send information relating to a file transfer session.
2442 @param accept: whether or not to go ahead with the transfer
2444 @param iCookie: the invitation cookie of previous replies
2445 relating to this transfer
2446 @param authCookie: the authentication cookie obtained from
2447 an FileSend instance
2449 @param port: the port on which an FileSend protocol is listening.
2452 m
.setHeader('Content-Type', 'text/x-msmsgsinvite; charset=UTF-8')
2453 m
.message
+= 'Invitation-Command: %s\r\n' % (accept
and 'ACCEPT' or 'CANCEL')
2454 m
.message
+= 'Invitation-Cookie: %s\r\n' % iCookie
2455 m
.message
+= 'IP-Address: %s\r\n' % ip
2456 m
.message
+= 'Port: %s\r\n' % port
2457 m
.message
+= 'AuthCookie: %s\r\n' % authCookie
2459 m
.ack
= m
.MESSAGE_NACK
2464 def __init__(self
, filename
, filesize
, userHandle
):
2465 self
.consumer
= None
2466 self
.finished
= False
2469 self
.filename
, self
.filesize
, self
.userHandle
= filename
, filesize
, userHandle
2472 raise NotImplementedError
2474 def accept(self
, consumer
):
2475 if self
.consumer
: raise "AlreadyAccepted"
2476 self
.consumer
= consumer
2477 for data
in self
.buffer:
2478 self
.consumer
.write(data
)
2481 self
.consumer
.close()
2483 self
.consumer
.error()
2485 def write(self
, data
):
2486 if self
.error
or self
.finished
:
2487 raise IOError, "Attempt to write in an invalid state"
2489 self
.consumer
.write(data
)
2491 self
.buffer.append(data
)
2494 self
.finished
= True
2496 self
.consumer
.close()
2499 """ Represents the Context field for P2P file transfers """
2500 def __init__(self
, data
=""):
2508 if MSNP2PDEBUG
: log
.msg("FileContext packing:", self
.filename
, self
.filesize
)
2509 data
= struct
.pack("<LLQL", 638, 0x03, self
.filesize
, 0x01)
2510 data
= data
[:-1] # Uck, weird, but it works
2511 data
+= utf16net(self
.filename
)
2512 data
= ljust(data
, 570, '\0')
2513 data
+= struct
.pack("<L", 0xFFFFFFFFL
)
2514 data
= ljust(data
, 638, '\0')
2517 def parse(self
, packet
):
2518 self
.filesize
= struct
.unpack("<Q", packet
[8:16])[0]
2519 chunk
= packet
[19:540]
2520 chunk
= chunk
[:chunk
.find('\x00\x00')]
2521 self
.filename
= unicode((codecs
.BOM_UTF16_BE
+ chunk
).decode("utf-16"))
2522 if MSNP2PDEBUG
: log
.msg("FileContext parsed:", self
.filesize
, self
.filename
)
2526 """ Utility class for the binary header & footer in p2p messages """
2535 def __init__(self
, fields
=None, packet
=None):
2537 self
.fields
= fields
2539 self
.fields
= [0] * 10
2541 self
.unpackFields(packet
)
2543 def __getitem__(self
, key
):
2544 return self
.fields
[key
]
2546 def __setitem__(self
, key
, value
):
2547 self
.fields
[key
] = value
2549 def unpackFields(self
, packet
):
2550 self
.fields
= struct
.unpack("<LLQQLLLLQ", packet
[0:48])
2551 self
.fields
+= struct
.unpack(">L", packet
[len(packet
)-4:])
2553 out
= "Unpacked fields: "
2554 for i
in self
.fields
:
2558 def packHeaders(self
):
2559 f
= tuple(self
.fields
)
2561 out
= "Packed fields: "
2562 for i
in self
.fields
:
2565 return struct
.pack("<LLQQLLLLQ", f
[0], f
[1], f
[2], f
[3], f
[4], f
[5], f
[6], f
[7], f
[8])
2567 def packFooter(self
):
2568 return struct
.pack(">L", self
.fields
[9])
2571 class MSNSLPMessage
:
2572 """ Representation of a single MSNSLP message """
2573 def __init__(self
, packet
=None):
2580 self
.sessionGuid
= ""
2581 self
.sessionID
= None
2583 self
.data
= "\r\n" + chr(0)
2587 def create(self
, method
=None, status
=None, to
=None, fro
=None, branch
=None, cseq
=0, sessionGuid
=None, data
=None):
2588 self
.method
= method
2589 self
.status
= status
2592 self
.branch
= branch
2594 self
.sessionGuid
= sessionGuid
2595 if data
: self
.data
= data
2597 def setData(self
, ctype
, data
):
2600 order
= ["EUF-GUID", "SessionID", "AppID", "Context", "Bridge", "Listening","Bridges", "NetID", "Conn-Type", "UPnPNat", "ICF", "Hashed-Nonce"]
2602 if key
== "Context" and data
.has_key(key
):
2603 s
.append("Context: %s\r\n" % b64enc(data
[key
]))
2604 elif data
.has_key(key
):
2605 s
.append("%s: %s\r\n" % (key
, str(data
[key
])))
2606 s
.append("\r\n"+chr(0))
2608 self
.data
= "".join(s
)
2612 if s
.find("MSNSLP/1.0") < 0: return
2614 lines
= s
.split("\r\n")
2616 # Get the MSNSLP method or status
2617 msnslp
= lines
[0].split(" ")
2618 if MSNP2PDEBUG
: log
.msg("Parsing MSNSLPMessage %s %s" % (len(s
), s
))
2619 if msnslp
[0] in ("INVITE", "BYE"):
2620 self
.method
= msnslp
[0].strip()
2622 self
.status
= msnslp
[1].strip()
2624 lines
.remove(lines
[0])
2627 line
= line
.split(":")
2628 if len(line
) < 1: continue
2630 if len(line
) > 2 and line
[0] == "To":
2631 self
.to
= line
[2][:line
[2].find('>')]
2632 elif len(line
) > 2 and line
[0] == "From":
2633 self
.fro
= line
[2][:line
[2].find('>')]
2634 elif line
[0] == "Call-ID":
2635 self
.sessionGuid
= line
[1].strip()
2636 elif line
[0] == "CSeq":
2637 self
.cseq
= int(line
[1].strip())
2638 elif line
[0] == "SessionID":
2639 self
.sessionID
= int(line
[1].strip())
2640 elif line
[0] == "EUF-GUID":
2641 self
.euf_guid
= line
[1].strip()
2642 elif line
[0] == "Content-Type":
2643 self
.ctype
= line
[1].strip()
2644 elif line
[0] == "Context":
2645 self
.context
= b64dec(line
[1])
2646 elif line
[0] == "Via":
2647 self
.branch
= line
[1].split(";")[1].split("=")[1].strip()
2650 log
.msg("Error parsing MSNSLP message.")
2656 s
.append("%s MSNMSGR:%s MSNSLP/1.0\r\n" % (self
.method
, self
.to
))
2658 if self
.status
== "200": status
= "200 OK"
2659 elif self
.status
== "603": status
= "603 Decline"
2660 s
.append("MSNSLP/1.0 %s\r\n" % status
)
2661 s
.append("To: <msnmsgr:%s>\r\n" % self
.to
)
2662 s
.append("From: <msnmsgr:%s>\r\n" % self
.fro
)
2663 s
.append("Via: MSNSLP/1.0/TLP ;branch=%s\r\n" % self
.branch
)
2664 s
.append("CSeq: %s \r\n" % str(self
.cseq
))
2665 s
.append("Call-ID: %s\r\n" % self
.sessionGuid
)
2666 s
.append("Max-Forwards: 0\r\n")
2667 s
.append("Content-Type: %s\r\n" % self
.ctype
)
2668 s
.append("Content-Length: %s\r\n\r\n" % len(self
.data
))
2673 """ Utility for handling the weird sequence IDs in p2p messages """
2674 def __init__(self
, baseID
=None):
2676 self
.baseID
= baseID
2678 self
.baseID
= random
.randint(1000, sys
.maxint
)
2682 return p2pseq(self
.pos
) + self
.baseID
2689 class StringBuffer(StringIO
.StringIO
):
2690 def __init__(self
, notifyFunc
=None):
2691 self
.notifyFunc
= notifyFunc
2692 StringIO
.StringIO
.__init
__(self
)
2696 self
.notifyFunc(self
.getvalue())
2697 self
.notifyFunc
= None
2698 StringIO
.StringIO
.close(self
)
2702 def __init__(self
, remoteUser
, switchboard
, sessionID
, sessionGuid
):
2705 sessionID
= random
.randint(1000, sys
.maxint
)
2707 sessionGuid
= random_guid()
2708 self
.remoteUser
= remoteUser
2709 self
.switchboard
= switchboard
2710 self
.sessionID
= sessionID
2711 self
.sessionGuid
= sessionGuid
2712 self
.seqID
= SeqID()
2716 if not self
.switchboard
: return
2717 del self
.switchboard
.slpLinks
[self
.sessionID
]
2718 self
.switchboard
= None
2719 # This is so that handleP2PMessage can still use the SLPLink
2720 # one last time, for ACKing BYEs and 601s.
2721 reactor
.callLater(0, kill
)
2723 def warn(self
, text
):
2724 log
.msg("Warning in transfer: %s %s" % (self
, text
))
2726 def sendP2PACK(self
, ackHeaders
):
2727 binaryFields
= BinaryFields()
2728 binaryFields
[0] = ackHeaders
[0]
2729 binaryFields
[1] = self
.seqID
.next()
2730 binaryFields
[3] = ackHeaders
[3]
2731 binaryFields
[5] = BinaryFields
.ACK
2732 binaryFields
[6] = ackHeaders
[1]
2733 binaryFields
[7] = ackHeaders
[6]
2734 binaryFields
[8] = ackHeaders
[3]
2735 self
.sendP2PMessage(binaryFields
, "")
2737 def sendSLPMessage(self
, cmd
, ctype
, data
, branch
=None):
2738 msg
= MSNSLPMessage()
2740 msg
.create(status
=cmd
, to
=self
.remoteUser
, fro
=self
.switchboard
.userHandle
, branch
=branch
, cseq
=1, sessionGuid
=self
.sessionGuid
)
2742 msg
.create(method
=cmd
, to
=self
.remoteUser
, fro
=self
.switchboard
.userHandle
, branch
=random_guid(), cseq
=0, sessionGuid
=self
.sessionGuid
)
2743 msg
.setData(ctype
, data
)
2745 binaryFields
= BinaryFields()
2746 binaryFields
[1] = self
.seqID
.next()
2747 binaryFields
[3] = len(msgStr
)
2748 binaryFields
[4] = binaryFields
[3]
2749 binaryFields
[6] = random
.randint(1000, sys
.maxint
)
2750 self
.sendP2PMessage(binaryFields
, msgStr
)
2752 def sendP2PMessage(self
, binaryFields
, msgStr
):
2753 packet
= binaryFields
.packHeaders() + msgStr
+ binaryFields
.packFooter()
2755 message
= MSNMessage(message
=packet
)
2756 message
.setHeader("Content-Type", "application/x-msnmsgrp2p")
2757 message
.setHeader("P2P-Dest", self
.remoteUser
)
2758 message
.ack
= MSNMessage
.MESSAGE_ACK_FAT
2759 self
.switchboard
.sendMessage(message
)
2761 def handleSLPMessage(self
, slpMessage
):
2762 raise NotImplementedError
2768 class SLPLink_Send(SLPLink
):
2769 def __init__(self
, remoteUser
, switchboard
, filesize
, sessionID
=None, sessionGuid
=None):
2770 SLPLink
.__init
__(self
, remoteUser
, switchboard
, sessionID
, sessionGuid
)
2771 self
.handlePacket
= None
2773 self
.filesize
= filesize
2776 def send_dataprep(self
):
2777 if MSNP2PDEBUG
: log
.msg("send_dataprep")
2778 binaryFields
= BinaryFields()
2779 binaryFields
[0] = self
.sessionID
2780 binaryFields
[1] = self
.seqID
.next()
2783 binaryFields
[6] = random
.randint(1000, sys
.maxint
)
2785 self
.sendP2PMessage(binaryFields
, chr(0) * 4)
2787 def write(self
, data
):
2788 if MSNP2PDEBUG
: log
.msg("write")
2790 data
= self
.data
+ data
2794 if i
+ 1202 < length
:
2795 self
._writeChunk
(data
[i
:i
+1202])
2798 self
.data
= data
[i
:]
2801 def _writeChunk(self
, chunk
):
2802 if MSNP2PDEBUG
: log
.msg("writing chunk")
2803 binaryFields
= BinaryFields()
2804 binaryFields
[0] = self
.sessionID
2805 if self
.offset
== 0:
2806 binaryFields
[1] = self
.seqID
.next()
2808 binaryFields
[1] = self
.seqID
.get()
2809 binaryFields
[2] = self
.offset
2810 binaryFields
[3] = self
.filesize
2811 binaryFields
[4] = len(chunk
)
2812 binaryFields
[5] = self
.dataFlag
2813 binaryFields
[6] = random
.randint(1000, sys
.maxint
)
2815 self
.offset
+= len(chunk
)
2816 self
.sendP2PMessage(binaryFields
, chunk
)
2820 self
._writeChunk
(self
.data
)
2825 # FIXME, should send 601 or something
2827 class SLPLink_FileSend(SLPLink_Send
):
2828 def __init__(self
, remoteUser
, switchboard
, filename
, filesize
):
2829 SLPLink_Send
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, filesize
=filesize
)
2830 self
.dataFlag
= BinaryFields
.DATAFT
2831 # Send invite & wait for 200OK before sending dataprep
2832 context
= FileContext()
2833 context
.filename
= filename
2834 context
.filesize
= filesize
2835 data
= {"EUF-GUID" : MSN_MSNFTP_GUID
,\
2836 "SessionID": self
.sessionID
,\
2838 "Context" : context
.pack() }
2839 self
.sendSLPMessage("INVITE", "application/x-msnmsgr-sessionreqbody", data
)
2840 self
.acceptDeferred
= Deferred()
2842 def handleSLPMessage(self
, slpMessage
):
2843 if slpMessage
.status
== "200":
2844 if slpMessage
.ctype
== "application/x-msnmsgr-sessionreqbody":
2845 data
= {"Bridges" : "TRUDPv1 TCPv1",\
2847 "Conn-Type" : "Firewall",\
2848 "UPnPNat" : "false",\
2850 #"Hashed-Nonce": random_guid()}
2851 self
.sendSLPMessage("INVITE", "application/x-msnmsgr-transreqbody", data
)
2852 elif slpMessage
.ctype
== "application/x-msnmsgr-transrespbody":
2853 self
.acceptDeferred
.callback((True,))
2854 self
.handlePacket
= self
.wait_data_ack
2856 if slpMessage
.status
== "603":
2857 self
.acceptDeferred
.callback((False,))
2858 # SLPLink is over due to decline, error or BYE
2861 def wait_data_ack(self
, packet
):
2862 if MSNP2PDEBUG
: log
.msg("wait_data_ack")
2863 binaryFields
= BinaryFields()
2864 binaryFields
.unpackFields(packet
)
2866 if binaryFields
[5] != BinaryFields
.ACK
:
2867 self
.warn("field5," + str(binaryFields
[5]))
2870 self
.sendSLPMessage("BYE", "application/x-msnmsgr-sessionclosebody", {})
2871 self
.handlePacket
= None
2874 self
.handlePacket
= self
.wait_data_ack
2875 SLPLink_Send
.close(self
)
2878 class SLPLink_AvatarSend(SLPLink_Send
):
2879 def __init__(self
, remoteUser
, switchboard
, filesize
, sessionID
=None, sessionGuid
=None):
2880 SLPLink_Send
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, filesize
=filesize
, sessionID
=sessionID
, sessionGuid
=sessionGuid
)
2881 self
.dataFlag
= BinaryFields
.DATA
2882 self
.sendSLPMessage("200", "application/x-msnmsgr-sessionreqbody", {"SessionID":self
.sessionID
})
2883 self
.send_dataprep()
2884 self
.handlePacket
= lambda packet
: None
2886 def handleSLPMessage(self
, slpMessage
):
2887 self
.killLink() # BYE or error
2890 SLPLink_Send
.close(self
)
2891 # Keep the link open to wait for a BYE
2893 class SLPLink_Receive(SLPLink
):
2894 def __init__(self
, remoteUser
, switchboard
, consumer
, context
=None, sessionID
=None, sessionGuid
=None):
2895 SLPLink
.__init
__(self
, remoteUser
, switchboard
, sessionID
, sessionGuid
)
2896 self
.handlePacket
= None
2897 self
.consumer
= consumer
2900 def wait_dataprep(self
, packet
):
2901 if MSNP2PDEBUG
: log
.msg("wait_dataprep")
2902 binaryFields
= BinaryFields()
2903 binaryFields
.unpackFields(packet
)
2905 if binaryFields
[3] != 4:
2906 self
.warn("field3," + str(binaryFields
[3]))
2908 if binaryFields
[4] != 4:
2909 self
.warn("field4," + str(binaryFields
[4]))
2911 # Just ignore the footer
2912 #if binaryFields[9] != 1:
2913 # self.warn("field9," + str(binaryFields[9]))
2916 self
.sendP2PACK(binaryFields
)
2917 self
.handlePacket
= self
.wait_data
2919 def wait_data(self
, packet
):
2920 if MSNP2PDEBUG
: log
.msg("wait_data")
2921 binaryFields
= BinaryFields()
2922 binaryFields
.unpackFields(packet
)
2924 if binaryFields
[5] != self
.dataFlag
:
2925 self
.warn("field5," + str(binaryFields
[5]))
2927 # Just ignore the footer
2928 #if binaryFields[9] != 1:
2929 # self.warn("field9," + str(binaryFields[9]))
2931 offset
= binaryFields
[2]
2932 total
= binaryFields
[3]
2933 length
= binaryFields
[4]
2935 data
= packet
[48:-4]
2936 if offset
!= self
.pos
:
2937 self
.warn("Received packet out of order")
2938 self
.consumer
.error()
2940 if len(data
) != length
:
2941 self
.warn("Received bad length of slp")
2942 self
.consumer
.error()
2947 self
.consumer
.write(str(data
))
2949 if self
.pos
== total
:
2950 self
.sendP2PACK(binaryFields
)
2951 self
.consumer
.close()
2952 self
.handlePacket
= None
2955 def doFinished(self
):
2956 raise NotImplementedError
2959 class SLPLink_FileReceive(SLPLink_Receive
, FileReceive
):
2960 def __init__(self
, remoteUser
, switchboard
, filename
, filesize
, sessionID
, sessionGuid
, branch
):
2961 SLPLink_Receive
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, consumer
=self
, sessionID
=sessionID
, sessionGuid
=sessionGuid
)
2962 self
.dataFlag
= BinaryFields
.DATAFT
2963 self
.initialBranch
= branch
2964 FileReceive
.__init
__(self
, filename
, filesize
, remoteUser
)
2967 # Send a 603 decline
2968 self
.sendSLPMessage("603", "application/x-msnmsgr-sessionreqbody", {"SessionID":self
.sessionID
}, branch
=self
.initialBranch
)
2971 def accept(self
, consumer
):
2972 FileReceive
.accept(self
, consumer
)
2973 self
.sendSLPMessage("200", "application/x-msnmsgr-sessionreqbody", {"SessionID":self
.sessionID
}, branch
=self
.initialBranch
)
2975 def handleSLPMessage(self
, slpMessage
):
2976 if slpMessage
.method
== "INVITE": # The second invite
2977 data
= {"Bridge" : "TCPv1",\
2978 "Listening" : "false",\
2979 "Hashed-Nonce": "{00000000-0000-0000-0000-000000000000}"}
2980 self
.sendSLPMessage("200", "application/x-msnmsgr-transrespbody", data
, branch
=slpMessage
.branch
)
2981 self
.handlePacket
= self
.wait_data
2983 self
.killLink() # It's either a BYE or an error
2984 # FIXME, do some error handling if it was an error
2986 def doFinished(self
):
2987 #self.sendSLPMessage("BYE", "application/x-msnmsgr-sessionclosebody", {})
2989 # Wait for BYE? #FIXME
2992 class SLPLink_AvatarReceive(SLPLink_Receive
):
2993 def __init__(self
, remoteUser
, switchboard
, consumer
, context
):
2994 SLPLink_Receive
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, consumer
=consumer
, context
=context
)
2995 self
.dataFlag
= BinaryFields
.DATA
2996 data
= {"EUF-GUID" : MSN_AVATAR_GUID
,\
2997 "SessionID": self
.sessionID
,\
2999 "Context" : context
}
3000 self
.sendSLPMessage("INVITE", "application/x-msnmsgr-sessionreqbody", data
)
3002 def handleSLPMessage(self
, slpMessage
):
3003 if slpMessage
.status
== "200":
3004 self
.handlePacket
= self
.wait_dataprep
3006 # SLPLink is over due to error or BYE
3009 def doFinished(self
):
3010 self
.sendSLPMessage("BYE", "application/x-msnmsgr-sessionclosebody", {})
3012 # mapping of error codes to error messages
3015 200 : "Syntax error",
3016 201 : "Invalid parameter",
3017 205 : "Invalid user",
3018 206 : "Domain name missing",
3019 207 : "Already logged in",
3020 208 : "Invalid username",
3021 209 : "Invalid screen name",
3022 210 : "User list full",
3023 215 : "User already there",
3024 216 : "User already on list",
3025 217 : "User not online",
3026 218 : "Already in mode",
3027 219 : "User is in the opposite list",
3028 223 : "Too many groups",
3029 224 : "Invalid group",
3030 225 : "User not in group",
3031 229 : "Group name too long",
3032 230 : "Cannot remove group 0",
3033 231 : "Invalid group",
3034 280 : "Switchboard failed",
3035 281 : "Transfer to switchboard failed",
3037 300 : "Required field missing",
3038 301 : "Too many FND responses",
3039 302 : "Not logged in",
3041 402 : "Error accessing contact list",
3042 403 : "Error accessing contact list",
3044 500 : "Internal server error",
3045 501 : "Database server error",
3046 502 : "Command disabled",
3047 510 : "File operation failed",
3048 520 : "Memory allocation failed",
3049 540 : "Wrong CHL value sent to server",
3051 600 : "Server is busy",
3052 601 : "Server is unavaliable",
3053 602 : "Peer nameserver is down",
3054 603 : "Database connection failed",
3055 604 : "Server is going down",
3056 605 : "Server unavailable",
3058 707 : "Could not create connection",
3059 710 : "Invalid CVR parameters",
3060 711 : "Write is blocking",
3061 712 : "Session is overloaded",
3062 713 : "Too many active users",
3063 714 : "Too many sessions",
3064 715 : "Not expected",
3065 717 : "Bad friend file",
3066 731 : "Not expected",
3068 800 : "Requests too rapid",
3070 910 : "Server too busy",
3071 911 : "Authentication failed",
3072 912 : "Server too busy",
3073 913 : "Not allowed when offline",
3074 914 : "Server too busy",
3075 915 : "Server too busy",
3076 916 : "Server too busy",
3077 917 : "Server too busy",
3078 918 : "Server too busy",
3079 919 : "Server too busy",
3080 920 : "Not accepting new users",
3081 921 : "Server too busy",
3082 922 : "Server too busy",
3083 923 : "No parent consent",
3084 924 : "Passport account not yet verified"
3088 # mapping of status codes to readable status format
3091 STATUS_ONLINE
: "Online",
3092 STATUS_OFFLINE
: "Offline",
3093 STATUS_HIDDEN
: "Appear Offline",
3094 STATUS_IDLE
: "Idle",
3095 STATUS_AWAY
: "Away",
3096 STATUS_BUSY
: "Busy",
3097 STATUS_BRB
: "Be Right Back",
3098 STATUS_PHONE
: "On the Phone",
3099 STATUS_LUNCH
: "Out to Lunch"
3103 # mapping of list ids to list codes
3106 FORWARD_LIST
: 'fl',
3109 REVERSE_LIST
: 'rl',
3114 # mapping of list codes to list ids
3116 for id,code
in listIDToCode
.items():
3117 listCodeToID
[code
] = id