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 ReconnectingClientFactory
, 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'
162 P2PSEQ
= [-3, -2, 0, -1, 1, 2, 3, 4, 5, 6, 7, 8]
171 return inp
.split('=')[1]
183 userHandle
= getVal(p
)
185 screenName
= unquote(getVal(p
))
190 else: # Must be the groups
192 groups
= p
.split(',')
194 raise MSNProtocolError
, "Unknown LST/ADC response" + str(params
) # debug
196 return userHandle
, screenName
, userGuid
, lists
, groups
199 """ Needed for Python 2.3 compatibility """
200 return s
+ (n
-len(s
))*c
202 if sys
.byteorder
== "little":
204 """ Encodes to utf-16 and ensures network byte order. Strips the BOM """
205 a
= array
.array("h", s
.encode("utf-16")[2:])
210 """ Encodes to utf-16 and ensures network byte order. Strips the BOM """
211 return s
.encode("utf-16")[2:]
214 return base64
.encodestring(s
).replace("\n", "")
217 for pad
in ["", "=", "==", "A", "A=", "A=="]: # Stupid MSN client!
219 return base64
.decodestring(s
+ pad
)
222 raise ValueError("Got some very bad base64!")
225 format
= "{%4X%4X-%4X-%4X-%4X-%4X%4X%4X}"
228 data
.append(random
.random() * 0xAAFF + 0x1111)
233 def checkParamLen(num
, expected
, cmd
, error
=None):
234 if error
== None: error
= "Invalid Number of Parameters for %s" % cmd
235 if num
!= expected
: raise MSNProtocolError
, error
237 def _parseHeader(h
, v
):
239 Split a certin number of known
240 header values with the format:
241 field1=val,field2=val,field3=val into
242 a dict mapping fields to values.
243 @param h: the header's key
244 @param v: the header's value as a string
247 if h
in ('passporturls','authentication-info','www-authenticate'):
248 v
= v
.replace('Passport1.4','').lstrip()
250 for fieldPair
in v
.split(','):
252 field
,value
= fieldPair
.split('=',1)
253 fields
[field
.lower()] = value
255 fields
[field
.lower()] = ''
259 def _parsePrimitiveHost(host
):
261 h
,p
= host
.replace('https://','').split('/',1)
265 def _login(userHandle
, passwd
, nexusServer
, cached
=0, authData
=''):
267 This function is used internally and should not ever be called
271 def _cb(server
, auth
):
272 loginFac
= ClientFactory()
273 loginFac
.protocol
= lambda : PassportLogin(cb
, userHandle
, passwd
, server
, auth
)
274 reactor
.connectSSL(_parsePrimitiveHost(server
)[0], 443, loginFac
, ClientContextFactory())
277 _cb(nexusServer
, authData
)
279 fac
= ClientFactory()
281 d
.addCallbacks(_cb
, callbackArgs
=(authData
,))
282 d
.addErrback(lambda f
: cb
.errback(f
))
283 fac
.protocol
= lambda : PassportNexus(d
, nexusServer
)
284 reactor
.connectSSL(_parsePrimitiveHost(nexusServer
)[0], 443, fac
, ClientContextFactory())
288 class PassportNexus(HTTPClient
):
291 Used to obtain the URL of a valid passport
294 This class is used internally and should
295 not be instantiated directly -- that is,
296 The passport logging in process is handled
297 transparantly by NotificationClient.
300 def __init__(self
, deferred
, host
):
301 self
.deferred
= deferred
302 self
.host
, self
.path
= _parsePrimitiveHost(host
)
304 def connectionMade(self
):
305 HTTPClient
.connectionMade(self
)
306 self
.sendCommand('GET', self
.path
)
307 self
.sendHeader('Host', self
.host
)
311 def handleHeader(self
, header
, value
):
313 self
.headers
[h
] = _parseHeader(h
, value
)
315 def handleEndHeaders(self
):
316 if self
.connected
: self
.transport
.loseConnection()
317 if not self
.headers
.has_key('passporturls') or not self
.headers
['passporturls'].has_key('dalogin'):
318 self
.deferred
.errback(failure
.Failure(failure
.DefaultException("Invalid Nexus Reply")))
320 self
.deferred
.callback('https://' + self
.headers
['passporturls']['dalogin'])
322 def handleResponse(self
, r
): pass
324 class PassportLogin(HTTPClient
):
326 This class is used internally to obtain
327 a login ticket from a passport HTTPS
328 server -- it should not be used directly.
333 def __init__(self
, deferred
, userHandle
, passwd
, host
, authData
):
334 self
.deferred
= deferred
335 self
.userHandle
= userHandle
337 self
.authData
= authData
338 self
.host
, self
.path
= _parsePrimitiveHost(host
)
340 def connectionMade(self
):
341 self
.sendCommand('GET', self
.path
)
342 self
.sendHeader('Authorization', 'Passport1.4 OrgVerb=GET,OrgURL=http://messenger.msn.com,' +
343 'sign-in=%s,pwd=%s,%s' % (quote(self
.userHandle
), quote(self
.passwd
), self
.authData
))
344 self
.sendHeader('Host', self
.host
)
348 def handleHeader(self
, header
, value
):
350 self
.headers
[h
] = _parseHeader(h
, value
)
352 def handleEndHeaders(self
):
353 if self
._finished
: return
354 self
._finished
= 1 # I think we need this because of HTTPClient
355 if self
.connected
: self
.transport
.loseConnection()
356 authHeader
= 'authentication-info'
357 _interHeader
= 'www-authenticate'
358 if self
.headers
.has_key(_interHeader
): authHeader
= _interHeader
360 info
= self
.headers
[authHeader
]
361 status
= info
['da-status']
362 handler
= getattr(self
, 'login_%s' % (status
,), None)
365 else: raise Exception()
367 self
.deferred
.errback(failure
.Failure(e
))
369 def handleResponse(self
, r
): pass
371 def login_success(self
, info
):
372 ticket
= info
['from-pp']
373 ticket
= ticket
[1:len(ticket
)-1]
374 self
.deferred
.callback((LOGIN_SUCCESS
, ticket
))
376 def login_failed(self
, info
):
377 self
.deferred
.callback((LOGIN_FAILURE
, unquote(info
['cbtxt'])))
379 def login_redir(self
, info
):
380 self
.deferred
.callback((LOGIN_REDIRECT
, self
.headers
['location'], self
.authData
))
382 class MSNProtocolError(Exception):
384 This Exception is basically used for debugging
385 purposes, as the official MSN server should never
386 send anything _wrong_ and nobody in their right
387 mind would run their B{own} MSN server.
388 If it is raised by default command handlers
389 (handle_BLAH) the error will be logged.
396 I am the class used to represent an 'instant' message.
398 @ivar userHandle: The user handle (passport) of the sender
399 (this is only used when receiving a message)
400 @ivar screenName: The screen name of the sender (this is only used
401 when receiving a message)
402 @ivar message: The message
403 @ivar headers: The message headers
405 @ivar length: The message length (including headers and line endings)
406 @ivar ack: This variable is used to tell the server how to respond
407 once the message has been sent. If set to MESSAGE_ACK
408 (default) the server will respond with an ACK upon receiving
409 the message, if set to MESSAGE_NACK the server will respond
410 with a NACK upon failure to receive the message.
411 If set to MESSAGE_ACK_NONE the server will do nothing.
412 This is relevant for the return value of
413 SwitchboardClient.sendMessage (which will return
414 a Deferred if ack is set to either MESSAGE_ACK or MESSAGE_NACK
415 and will fire when the respective ACK or NACK is received).
416 If set to MESSAGE_ACK_NONE sendMessage will return None.
419 MESSAGE_ACK_FAT
= 'D'
421 MESSAGE_ACK_NONE
= 'U'
425 def __init__(self
, length
=0, userHandle
="", screenName
="", message
="", specialMessage
=False):
426 self
.userHandle
= userHandle
427 self
.screenName
= screenName
428 self
.specialMessage
= specialMessage
429 self
.message
= message
430 self
.headers
= {'MIME-Version' : '1.0', 'Content-Type' : 'text/plain; charset=UTF-8'}
434 def _calcMessageLen(self
):
436 used to calculte the number to send
437 as the message length when sending a message.
439 return reduce(operator
.add
, [len(x
[0]) + len(x
[1]) + 4 for x
in self
.headers
.items()]) + len(self
.message
) + 2
441 def delHeader(self
, header
):
442 """ delete the desired header """
443 if self
.headers
.has_key(header
):
444 del self
.headers
[header
]
446 def setHeader(self
, header
, value
):
447 """ set the desired header """
448 self
.headers
[header
] = value
450 def getHeader(self
, header
):
452 get the desired header value
453 @raise KeyError: if no such header exists.
455 return self
.headers
[header
]
457 def hasHeader(self
, header
):
458 """ check to see if the desired header exists """
459 return self
.headers
.has_key(header
)
461 def getMessage(self
):
462 """ return the message - not including headers """
465 def setMessage(self
, message
):
466 """ set the message text """
467 self
.message
= message
472 Used to represent a MSNObject. This can be currently only be an avatar.
474 @ivar creator: The userHandle of the creator of this picture.
475 @ivar imageData: The PNG image data (only for our own avatar)
476 @ivar type: Always set to 3, for avatar.
477 @ivar size: The size of the image.
478 @ivar location: The filename of the image.
479 @ivar friendly: Unknown.
480 @ivar text: The textual representation of this MSNObject.
482 def __init__(self
, s
=""):
483 """ Pass a XML MSNObject string to parse it, or pass no arguments for a null MSNObject to be created. """
488 def setData(self
, creator
, imageData
):
489 """ Set the creator and imageData for this object """
490 self
.creator
= creator
491 self
.imageData
= imageData
492 self
.size
= len(imageData
)
494 self
.location
= "TMP" + str(random
.randint(1000,9999))
495 self
.friendly
= "AAA="
496 self
.sha1d
= b64enc(sha
.sha(imageData
).digest())
510 """ Makes a textual representation of this MSNObject. Stores it in self.text """
513 h
.append(self
.creator
)
515 h
.append(str(self
.size
))
517 h
.append(str(self
.type))
519 h
.append(self
.location
)
521 h
.append(self
.friendly
)
524 sha1c
= b64enc(sha
.sha("".join(h
)).digest())
525 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
)
528 e
= xmlw
.parseText(s
, True)
530 return # Parse failed
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 not self
.connected
: return
790 if self
.currentMessage
:
791 self
.currentMessage
.readPos
+= len(line
+"\r\n")
793 header
, value
= line
.split(':')
794 self
.currentMessage
.setHeader(header
, unquote(value
).lstrip())
797 #raise MSNProtocolError, "Invalid Message Header"
799 if line
== "" or self
.currentMessage
.specialMessage
:
801 if self
.currentMessage
.readPos
== self
.currentMessage
.length
: self
.rawDataReceived("") # :(
804 cmd
, params
= line
.split(' ', 1)
806 raise MSNProtocolError
, "Invalid Message, %s" % repr(line
)
808 if len(cmd
) != 3: raise MSNProtocolError
, "Invalid Command, %s" % repr(cmd
)
810 id = params
.split(' ')[0]
811 if id.isdigit() and self
.ids
.has_key(int(id)):
813 self
.ids
[id][0].errback(int(cmd
))
816 else: # we received an error which doesn't map to a sent command
817 self
.gotError(int(cmd
))
820 handler
= getattr(self
, "handle_%s" % cmd
.upper(), None)
822 try: handler(params
.split(' '))
823 except MSNProtocolError
, why
: self
.gotBadLine(line
, why
)
825 self
.handle_UNKNOWN(cmd
, params
.split(' '))
827 def rawDataReceived(self
, data
):
828 if not self
.connected
: return
830 self
.currentMessage
.readPos
+= len(data
)
831 diff
= self
.currentMessage
.readPos
- self
.currentMessage
.length
833 self
.currentMessage
.message
+= data
[:-diff
]
836 self
.currentMessage
.message
+= data
838 self
.currentMessage
.message
+= data
840 del self
.currentMessage
.readPos
841 m
= self
.currentMessage
842 self
.currentMessage
= None
843 if MESSAGEDEBUG
: log
.msg(m
.message
)
845 if not self
.checkMessage(m
):
846 self
.setLineMode(extra
)
849 self
.setLineMode(extra
)
852 self
.setLineMode(extra
)
854 ### protocol command handlers - no need to override these.
856 def handle_MSG(self
, params
):
857 checkParamLen(len(params
), 3, 'MSG')
859 messageLen
= int(params
[2])
860 except ValueError: raise MSNProtocolError
, "Invalid Parameter for MSG length argument"
861 self
.currentMessage
= MSNMessage(length
=messageLen
, userHandle
=params
[0], screenName
=unquote(params
[1]))
863 def handle_UNKNOWN(self
, cmd
, params
):
864 """ implement me in subclasses if you want to handle unknown events """
865 log
.msg("Received unknown command (%s), params: %s" % (cmd
, params
))
869 def gotBadLine(self
, line
, why
):
870 """ called when a handler notifies me that this line is broken """
871 log
.msg('Error in line: %s (%s)' % (line
, why
))
873 def gotError(self
, errorCode
):
875 called when the server sends an error which is not in
876 response to a sent command (ie. it has no matching transaction ID)
878 log
.msg('Error %s' % (errorCodes
[errorCode
]))
881 class DispatchClient(MSNEventBase
):
883 This class provides support for clients connecting to the dispatch server
884 @ivar userHandle: your user handle (passport) needed before connecting.
887 def connectionMade(self
):
888 MSNEventBase
.connectionMade(self
)
889 self
.sendLine('VER %s %s' % (self
._nextTransactionID
(), MSN_PROTOCOL_VERSION
))
891 ### protocol command handlers ( there is no need to override these )
893 def handle_VER(self
, params
):
894 versions
= params
[1:]
895 if versions
is None or ' '.join(versions
) != MSN_PROTOCOL_VERSION
:
896 self
.transport
.loseConnection()
897 raise MSNProtocolError
, "Invalid version response"
898 id = self
._nextTransactionID
()
899 self
.sendLine("CVR %s %s %s" % (id, MSN_CVR_STR
, self
.factory
.userHandle
))
901 def handle_CVR(self
, params
):
902 self
.sendLine("USR %s TWN I %s" % (self
._nextTransactionID
(), self
.factory
.userHandle
))
904 def handle_XFR(self
, params
):
905 if len(params
) < 4: raise MSNProtocolError
, "Invalid number of parameters for XFR"
906 id, refType
, addr
= params
[:3]
907 # was addr a host:port pair?
909 host
, port
= addr
.split(':')
914 self
.gotNotificationReferral(host
, int(port
))
918 def gotNotificationReferral(self
, host
, port
):
920 called when we get a referral to the notification server.
922 @param host: the notification server's hostname
923 @param port: the port to connect to
928 class DispatchFactory(ClientFactory
):
930 This class keeps the state for the DispatchClient.
932 @ivar userHandle: the userHandle to request a notification
935 protocol
= DispatchClient
940 class NotificationClient(MSNEventBase
):
942 This class provides support for clients connecting
943 to the notification server.
946 factory
= None # sssh pychecker
948 def __init__(self
, currentID
=0):
949 MSNEventBase
.__init
__(self
)
950 self
.currentID
= currentID
951 self
._state
= ['DISCONNECTED', {}]
953 self
.pingCheckTask
= None
954 self
.msnobj
= MSNObject()
956 def _setState(self
, state
):
957 self
._state
[0] = state
960 return self
._state
[0]
962 def _getStateData(self
, key
):
963 return self
._state
[1][key
]
965 def _setStateData(self
, key
, value
):
966 self
._state
[1][key
] = value
968 def _remStateData(self
, *args
):
969 for key
in args
: del self
._state
[1][key
]
971 def connectionMade(self
):
972 MSNEventBase
.connectionMade(self
)
973 self
._setState
('CONNECTED')
974 self
.sendLine("VER %s %s" % (self
._nextTransactionID
(), MSN_PROTOCOL_VERSION
))
975 self
.factory
.resetDelay()
977 def connectionLost(self
, reason
):
978 self
._setState
('DISCONNECTED')
980 if self
.pingCheckTask
:
981 self
.pingCheckTask
.stop()
982 self
.pingCheckTask
= None
983 MSNEventBase
.connectionLost(self
, reason
)
985 def _getEmailFields(self
, message
):
986 fields
= message
.getMessage().strip().split('\n')
990 if len(a
) != 2: continue
997 def _gotInitialEmailNotification(self
, message
):
998 values
= self
._getEmailFields
(message
)
1000 inboxunread
= int(values
["Inbox-Unread"])
1001 foldersunread
= int(values
["Folders-Unread"])
1004 if foldersunread
+ inboxunread
> 0: # For some reason MSN sends notifications about empty inboxes sometimes?
1005 self
.gotInitialEmailNotification(inboxunread
, foldersunread
)
1007 def _gotEmailNotification(self
, message
):
1008 values
= self
._getEmailFields
(message
)
1010 mailfrom
= values
["From"]
1011 fromaddr
= values
["From-Addr"]
1012 subject
= values
["Subject"]
1013 junkbeginning
= "=?\"us-ascii\"?Q?"
1015 subject
= subject
.replace(junkbeginning
, "").replace(junkend
, "").replace("_", " ")
1017 # If any of the fields weren't found then it's not a big problem. We just ignore the message
1019 self
.gotRealtimeEmailNotification(mailfrom
, fromaddr
, subject
)
1021 def _gotMSNAlert(self
, message
):
1022 notification
= xmlw
.parseText(message
.message
, beExtremelyLenient
=True)
1023 siteurl
= notification
.getAttribute("siteurl")
1024 notid
= notification
.getAttribute("id")
1027 for e
in notification
.elements():
1033 msgid
= msg
.getAttribute("id")
1038 for e
in msg
.elements():
1039 if e
.name
== "ACTION":
1040 action
= e
.getAttribute("url")
1041 if e
.name
== "SUBSCR":
1042 subscr
= e
.getAttribute("url")
1043 if e
.name
== "BODY":
1044 for e2
in e
.elements():
1045 if e2
.name
== "TEXT":
1046 bodytext
= e2
.__str__()
1047 if not (action
and subscr
and bodytext
): return
1049 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
1050 subscrurl
= "%s¬ification_id=%s&message_id=%s&agent=messenger" % (subscr
, notid
, msgid
)
1052 self
.gotMSNAlert(bodytext
, actionurl
, subscrurl
)
1054 def _gotUBX(self
, message
):
1055 msnContact
= self
.factory
.contacts
.getContact(message
.userHandle
)
1056 if not msnContact
: return
1057 lm
= message
.message
.lower()
1058 p1
= lm
.find("<psm>") + 5
1059 p2
= lm
.find("</psm>")
1060 if p1
>= 0 and p2
>= 0:
1061 personal
= xmlw
.unescapeFromXml(message
.message
[p1
:p2
])
1062 msnContact
.personal
= personal
1063 self
.contactPersonalChanged(message
.userHandle
, personal
)
1065 msnContact
.personal
= ''
1066 self
.contactPersonalChanged(message
.userHandle
, '')
1068 def checkMessage(self
, message
):
1069 """ hook used for detecting specific notification messages """
1070 cTypes
= [s
.lstrip() for s
in message
.getHeader('Content-Type').split(';')]
1071 if 'text/x-msmsgsprofile' in cTypes
:
1072 self
.gotProfile(message
)
1074 elif "text/x-msmsgsinitialemailnotification" in cTypes
:
1075 self
._gotInitialEmailNotification
(message
)
1077 elif "text/x-msmsgsemailnotification" in cTypes
:
1078 self
._gotEmailNotification
(message
)
1080 elif "NOTIFICATION" == message
.userHandle
and message
.specialMessage
== True:
1081 self
._gotMSNAlert
(message
)
1083 elif "UBX" == message
.screenName
and message
.specialMessage
== True:
1084 self
._gotUBX
(message
)
1088 ### protocol command handlers - no need to override these
1090 def handle_VER(self
, params
):
1091 versions
= params
[1:]
1092 if versions
is None or ' '.join(versions
) != MSN_PROTOCOL_VERSION
:
1093 self
.transport
.loseConnection()
1094 raise MSNProtocolError
, "Invalid version response"
1095 self
.sendLine("CVR %s %s %s" % (self
._nextTransactionID
(), MSN_CVR_STR
, self
.factory
.userHandle
))
1097 def handle_CVR(self
, params
):
1098 self
.sendLine("USR %s TWN I %s" % (self
._nextTransactionID
(), self
.factory
.userHandle
))
1100 def handle_USR(self
, params
):
1101 if not (4 <= len(params
) <= 6):
1102 raise MSNProtocolError
, "Invalid Number of Parameters for USR"
1104 mechanism
= params
[1]
1105 if mechanism
== "OK":
1106 self
.loggedIn(params
[2], int(params
[3]))
1107 elif params
[2].upper() == "S":
1108 # we need to obtain auth from a passport server
1110 d
= _login(f
.userHandle
, f
.password
, f
.passportServer
, authData
=params
[3])
1111 d
.addCallback(self
._passportLogin
)
1112 d
.addErrback(self
._passportError
)
1114 def _passportLogin(self
, result
):
1115 if result
[0] == LOGIN_REDIRECT
:
1116 d
= _login(self
.factory
.userHandle
, self
.factory
.password
,
1117 result
[1], cached
=1, authData
=result
[2])
1118 d
.addCallback(self
._passportLogin
)
1119 d
.addErrback(self
._passportError
)
1120 elif result
[0] == LOGIN_SUCCESS
:
1121 self
.sendLine("USR %s TWN S %s" % (self
._nextTransactionID
(), result
[1]))
1122 elif result
[0] == LOGIN_FAILURE
:
1123 self
.loginFailure(result
[1])
1125 def _passportError(self
, failure
):
1126 self
.loginFailure("Exception while authenticating: %s" % failure
)
1128 def handle_CHG(self
, params
):
1130 if not self
._fireCallback
(id, params
[1]):
1131 if self
.factory
: self
.factory
.status
= params
[1]
1132 self
.statusChanged(params
[1])
1134 def handle_ILN(self
, params
):
1135 #checkParamLen(len(params), 6, 'ILN')
1136 msnContact
= self
.factory
.contacts
.getContact(params
[2])
1137 if not msnContact
: return
1138 msnContact
.status
= params
[1]
1139 msnContact
.screenName
= unquote(params
[3])
1140 if len(params
) > 4: msnContact
.caps
= int(params
[4])
1142 self
.handleAvatarHelper(msnContact
, params
[5])
1144 self
.handleAvatarGoneHelper(msnContact
)
1145 self
.gotContactStatus(params
[2], params
[1], unquote(params
[3]))
1147 def handleAvatarGoneHelper(self
, msnContact
):
1148 if msnContact
.msnobj
:
1149 msnContact
.msnobj
= None
1150 msnContact
.msnobjGot
= True
1151 self
.contactAvatarChanged(msnContact
.userHandle
, "")
1153 def handleAvatarHelper(self
, msnContact
, msnobjStr
):
1154 msnobj
= MSNObject(unquote(msnobjStr
))
1155 if not msnContact
.msnobj
or msnobj
.sha1d
!= msnContact
.msnobj
.sha1d
:
1156 if MSNP2PDEBUG
: log
.msg("Updated MSNObject received!" + msnobjStr
)
1157 msnContact
.msnobj
= msnobj
1158 msnContact
.msnobjGot
= False
1159 self
.contactAvatarChanged(msnContact
.userHandle
, binascii
.hexlify(b64dec(msnContact
.msnobj
.sha1d
)))
1161 def handle_CHL(self
, params
):
1162 checkParamLen(len(params
), 2, 'CHL')
1163 response
= msnp11chl
.doChallenge(params
[1])
1164 self
.sendLine("QRY %s %s %s" % (self
._nextTransactionID
(), msnp11chl
.MSNP11_PRODUCT_ID
, len(response
)))
1165 self
.transport
.write(response
)
1167 def handle_QRY(self
, params
):
1170 def handle_NLN(self
, params
):
1171 if not self
.factory
: return
1172 msnContact
= self
.factory
.contacts
.getContact(params
[1])
1173 if not msnContact
: return
1174 msnContact
.status
= params
[0]
1175 msnContact
.screenName
= unquote(params
[2])
1176 if len(params
) > 3: msnContact
.caps
= int(params
[3])
1178 self
.handleAvatarHelper(msnContact
, params
[4])
1180 self
.handleAvatarGoneHelper(msnContact
)
1181 self
.contactStatusChanged(params
[1], params
[0], unquote(params
[2]))
1183 def handle_FLN(self
, params
):
1184 checkParamLen(len(params
), 1, 'FLN')
1185 msnContact
= self
.factory
.contacts
.getContact(params
[0])
1187 msnContact
.status
= STATUS_OFFLINE
1188 self
.contactOffline(params
[0])
1190 def handle_LST(self
, params
):
1191 if self
._getState
() != 'SYNC': return
1193 userHandle
, screenName
, userGuid
, lists
, groups
= getVals(params
)
1195 if not userHandle
or lists
< 1:
1196 raise MSNProtocolError
, "Unknown LST " + str(params
) # debug
1197 contact
= MSNContact(userGuid
, userHandle
, screenName
, lists
)
1198 if contact
.lists
& FORWARD_LIST
:
1199 contact
.groups
.extend(map(str, groups
))
1200 self
._getStateData
('list').addContact(contact
)
1201 self
._setStateData
('last_contact', contact
)
1202 sofar
= self
._getStateData
('lst_sofar') + 1
1203 if sofar
== self
._getStateData
('lst_reply'):
1204 # this is the best place to determine that
1205 # a syn realy has finished - msn _may_ send
1206 # BPR information for the last contact
1207 # which is unfortunate because it means
1208 # that the real end of a syn is non-deterministic.
1209 # to handle this we'll keep 'last_contact' hanging
1210 # around in the state data and update it if we need
1212 self
._setState
('SESSION')
1213 contacts
= self
._getStateData
('list')
1214 phone
= self
._getStateData
('phone')
1215 id = self
._getStateData
('synid')
1216 self
._remStateData
('lst_reply', 'lsg_reply', 'lst_sofar', 'phone', 'synid', 'list')
1217 self
._fireCallback
(id, contacts
, phone
)
1219 self
._setStateData
('lst_sofar',sofar
)
1221 def handle_BLP(self
, params
):
1222 # check to see if this is in response to a SYN
1223 if self
._getState
() == 'SYNC':
1224 self
._getStateData
('list').privacy
= listCodeToID
[params
[0].lower()]
1227 self
.factory
.contacts
.privacy
= listCodeToID
[params
[1].lower()]
1228 self
._fireCallback
(id, params
[1])
1230 def handle_GTC(self
, params
):
1231 # check to see if this is in response to a SYN
1232 if self
._getState
() == 'SYNC':
1233 if params
[0].lower() == "a": self
._getStateData
('list').autoAdd
= 0
1234 elif params
[0].lower() == "n": self
._getStateData
('list').autoAdd
= 1
1235 else: raise MSNProtocolError
, "Invalid Paramater for GTC" # debug
1238 if params
[1].lower() == "a": self
._fireCallback
(id, 0)
1239 elif params
[1].lower() == "n": self
._fireCallback
(id, 1)
1240 else: raise MSNProtocolError
, "Invalid Paramater for GTC" # debug
1242 def handle_SYN(self
, params
):
1244 self
._setStateData
('phone', []) # Always needs to be set
1245 if params
[3] == 0: # No LST will be received. New account?
1246 self
._setState
('SESSION')
1247 self
._fireCallback
(id, None, None)
1249 contacts
= MSNContactList()
1250 self
._setStateData
('list', contacts
)
1251 self
._setStateData
('lst_reply', int(params
[3]))
1252 self
._setStateData
('lsg_reply', int(params
[4]))
1253 self
._setStateData
('lst_sofar', 0)
1255 def handle_LSG(self
, params
):
1256 if self
._getState
() == 'SYNC':
1257 self
._getStateData
('list').groups
[params
[1]] = unquote(params
[0])
1259 def handle_PRP(self
, params
):
1260 if params
[1] == "MFN":
1261 self
._fireCallback
(int(params
[0]))
1262 elif self
._getState
() == 'SYNC':
1263 self
._getStateData
('phone').append((params
[0], unquote(params
[1])))
1265 self
._fireCallback
(int(params
[0]), int(params
[1]), unquote(params
[3]))
1267 def handle_BPR(self
, params
):
1268 numParams
= len(params
)
1269 if numParams
== 2: # part of a syn
1270 self
._getStateData
('last_contact').setPhone(params
[0], unquote(params
[1]))
1271 elif numParams
== 4:
1272 if not self
.factory
.contacts
: raise MSNProtocolError
, "handle_BPR called with no contact list" # debug
1273 self
.factory
.contacts
.version
= int(params
[0])
1274 userHandle
, phoneType
, number
= params
[1], params
[2], unquote(params
[3])
1275 self
.factory
.contacts
.getContact(userHandle
).setPhone(phoneType
, number
)
1276 self
.gotPhoneNumber(userHandle
, phoneType
, number
)
1279 def handle_ADG(self
, params
):
1280 checkParamLen(len(params
), 5, 'ADG')
1282 if not self
._fireCallback
(id, int(params
[1]), unquote(params
[2]), int(params
[3])):
1283 raise MSNProtocolError
, "ADG response does not match up to a request" # debug
1285 def handle_RMG(self
, params
):
1286 checkParamLen(len(params
), 3, 'RMG')
1288 if not self
._fireCallback
(id, int(params
[1]), int(params
[2])):
1289 raise MSNProtocolError
, "RMG response does not match up to a request" # debug
1291 def handle_REG(self
, params
):
1292 checkParamLen(len(params
), 5, 'REG')
1294 if not self
._fireCallback
(id, int(params
[1]), int(params
[2]), unquote(params
[3])):
1295 raise MSNProtocolError
, "REG response does not match up to a request" # debug
1297 def handle_ADC(self
, params
):
1298 if not self
.factory
.contacts
: raise MSNProtocolError
, "handle_ADC called with no contact list"
1299 numParams
= len(params
)
1300 if numParams
< 3 or params
[1].upper() not in ('AL','BL','RL','FL','PL'):
1301 raise MSNProtocolError
, "Invalid Paramaters for ADC" # debug
1303 listType
= params
[1].lower()
1304 userHandle
, screenName
, userGuid
, ignored1
, groups
= getVals(params
[2:])
1306 if groups
and listType
.upper() != FORWARD_LIST
:
1307 raise MSNProtocolError
, "Only forward list can contain groups" # debug
1309 if not self
._fireCallback
(id, listCodeToID
[listType
], userGuid
, userHandle
, screenName
):
1310 c
= self
.factory
.contacts
.getContact(userHandle
)
1312 c
= MSNContact(userGuid
=userGuid
, userHandle
=userHandle
, screenName
=screenName
)
1313 self
.factory
.contacts
.addContact(c
)
1314 c
.addToList(PENDING_LIST
)
1315 self
.userAddedMe(userGuid
, userHandle
, screenName
)
1317 def handle_REM(self
, params
):
1318 if not self
.factory
.contacts
: raise MSNProtocolError
, "handle_REM called with no contact list available!"
1319 numParams
= len(params
)
1320 if numParams
< 3 or params
[1].upper() not in ('AL','BL','FL','RL','PL'):
1321 raise MSNProtocolError
, "Invalid Paramaters for REM" # debug
1323 listType
= params
[1].lower()
1324 userHandle
= params
[2]
1327 if params
[1] != "FL": raise MSNProtocolError
, "Only forward list can contain groups" # debug
1328 groupID
= int(params
[3])
1329 if not self
._fireCallback
(id, listCodeToID
[listType
], userHandle
, groupID
):
1330 if listType
.upper() != "RL": return
1331 c
= self
.factory
.contacts
.getContact(userHandle
)
1333 c
.removeFromList(REVERSE_LIST
)
1334 if c
.lists
== 0: self
.factory
.contacts
.remContact(c
.userHandle
)
1335 self
.userRemovedMe(userHandle
)
1337 def handle_XFR(self
, params
):
1338 checkParamLen(len(params
), 5, 'XFR')
1340 # check to see if they sent a host/port pair
1342 host
, port
= params
[2].split(':')
1347 if not self
._fireCallback
(id, host
, int(port
), params
[4]):
1348 raise MSNProtocolError
, "Got XFR (referral) that I didn't ask for .. should this happen?" # debug
1350 def handle_RNG(self
, params
):
1351 checkParamLen(len(params
), 6, 'RNG')
1352 # check for host:port pair
1354 host
, port
= params
[1].split(":")
1359 self
.gotSwitchboardInvitation(int(params
[0]), host
, port
, params
[3], params
[4],
1362 def handle_NOT(self
, params
):
1363 checkParamLen(len(params
), 1, 'NOT')
1365 messageLen
= int(params
[0])
1366 except ValueError: raise MSNProtocolError
, "Invalid Parameter for NOT length argument"
1367 self
.currentMessage
= MSNMessage(length
=messageLen
, userHandle
="NOTIFICATION", specialMessage
=True)
1370 def handle_UBX(self
, params
):
1371 checkParamLen(len(params
), 2, 'UBX')
1373 messageLen
= int(params
[1])
1374 except ValueError: raise MSNProtocolError
, "Invalid Parameter for UBX length argument"
1376 self
.currentMessage
= MSNMessage(length
=messageLen
, userHandle
=params
[0], screenName
="UBX", specialMessage
=True)
1379 self
._gotUBX
(MSNMessage(userHandle
=params
[0]))
1381 def handle_UUX(self
, params
):
1382 checkParamLen(len(params
), 2, 'UUX')
1383 if params
[1] != '0': return
1385 self
._fireCallback
(id)
1387 def handle_OUT(self
, params
):
1388 checkParamLen(len(params
), 1, 'OUT')
1389 self
.factory
.stopTrying()
1390 if params
[0] == "OTH": self
.multipleLogin()
1391 elif params
[0] == "SSD": self
.serverGoingDown()
1392 else: raise MSNProtocolError
, "Invalid Parameters received for OUT" # debug
1394 def handle_QNG(self
, params
):
1395 self
.pingCounter
= 0 # They replied to a ping. We'll forgive them for any they may have missed, because they're alive again now
1399 def pingChecker(self
):
1400 if self
.pingCounter
> 5:
1401 # The server has ignored 5 pings, lets kill the connection
1402 self
.transport
.loseConnection()
1404 self
.sendLine("PNG")
1405 self
.pingCounter
+= 1
1407 def pingCheckerStart(self
, *args
):
1408 self
.pingCheckTask
= task
.LoopingCall(self
.pingChecker
)
1409 self
.pingCheckTask
.start(PINGSPEED
)
1411 def loggedIn(self
, userHandle
, verified
):
1413 Called when the client has logged in.
1414 The default behaviour of this method is to
1415 update the factory with our screenName and
1416 to sync the contact list (factory.contacts).
1417 When this is complete self.listSynchronized
1420 @param userHandle: our userHandle
1421 @param verified: 1 if our passport has been (verified), 0 if not.
1422 (i'm not sure of the significace of this)
1426 d
.addCallback(self
.listSynchronized
)
1427 d
.addCallback(self
.pingCheckerStart
)
1429 def loginFailure(self
, message
):
1431 Called when the client fails to login.
1433 @param message: a message indicating the problem that was encountered
1437 def gotProfile(self
, message
):
1439 Called after logging in when the server sends an initial
1440 message with MSN/passport specific profile information
1441 such as country, number of kids, etc.
1442 Check the message headers for the specific values.
1444 @param message: The profile message
1448 def listSynchronized(self
, *args
):
1450 Lists are now synchronized by default upon logging in, this
1451 method is called after the synchronization has finished
1452 and the factory now has the up-to-date contacts.
1456 def contactAvatarChanged(self
, userHandle
, hash):
1458 Called when we receive the first, or a new <msnobj/> from a
1461 @param userHandle: contact who's msnobj has been changed
1462 @param hash: sha1 hash of their avatar as hex string
1465 def statusChanged(self
, statusCode
):
1467 Called when our status changes and its not in response to a
1470 @param statusCode: 3-letter status code
1474 def gotContactStatus(self
, userHandle
, statusCode
, screenName
):
1476 Called when we receive a list of statuses upon login.
1478 @param userHandle: the contact's user handle (passport)
1479 @param statusCode: 3-letter status code
1480 @param screenName: the contact's screen name
1484 def contactStatusChanged(self
, userHandle
, statusCode
, screenName
):
1486 Called when we're notified that a contact's status has changed.
1488 @param userHandle: the contact's user handle (passport)
1489 @param statusCode: 3-letter status code
1490 @param screenName: the contact's screen name
1494 def contactPersonalChanged(self
, userHandle
, personal
):
1496 Called when a contact's personal message changes.
1498 @param userHandle: the contact who changed their personal message
1499 @param personal : the new personal message
1503 def contactOffline(self
, userHandle
):
1505 Called when a contact goes offline.
1507 @param userHandle: the contact's user handle
1511 def gotMessage(self
, message
):
1513 Called when there is a message from the notification server
1514 that is not understood by default.
1516 @param message: the MSNMessage.
1520 def gotMSNAlert(self
, body
, action
, subscr
):
1522 Called when the server sends an MSN Alert (http://alerts.msn.com)
1524 @param body : the alert text
1525 @param action: a URL with more information for the user to view
1526 @param subscr: a URL the user can use to modify their alert subscription
1530 def gotInitialEmailNotification(self
, inboxunread
, foldersunread
):
1532 Called when the server sends you details about your hotmail
1533 inbox. This is only ever called once, on login.
1535 @param inboxunread : the number of unread items in your inbox
1536 @param foldersunread: the number of unread items in other folders
1540 def gotRealtimeEmailNotification(self
, mailfrom
, fromaddr
, subject
):
1542 Called when the server sends us realtime email
1543 notification. This means that you have received
1544 a new email in your hotmail inbox.
1546 @param mailfrom: the sender of the email
1547 @param fromaddr: the sender of the email (I don't know :P)
1548 @param subject : the email subject
1552 def gotPhoneNumber(self
, userHandle
, phoneType
, number
):
1554 Called when the server sends us phone details about
1555 a specific user (for example after a user is added
1556 the server will send their status, phone details etc.
1558 @param userHandle: the contact's user handle (passport)
1559 @param phoneType: the specific phoneType
1560 (*_PHONE constants or HAS_PAGER)
1561 @param number: the value/phone number.
1565 def userAddedMe(self
, userGuid
, userHandle
, screenName
):
1567 Called when a user adds me to their list. (ie. they have been added to
1570 @param userHandle: the userHandle of the user
1571 @param screenName: the screen name of the user
1575 def userRemovedMe(self
, userHandle
):
1577 Called when a user removes us from their contact list
1578 (they are no longer on our reverseContacts list.
1580 @param userHandle: the contact's user handle (passport)
1584 def gotSwitchboardInvitation(self
, sessionID
, host
, port
,
1585 key
, userHandle
, screenName
):
1587 Called when we get an invitation to a switchboard server.
1588 This happens when a user requests a chat session with us.
1590 @param sessionID: session ID number, must be remembered for logging in
1591 @param host: the hostname of the switchboard server
1592 @param port: the port to connect to
1593 @param key: used for authorization when connecting
1594 @param userHandle: the user handle of the person who invited us
1595 @param screenName: the screen name of the person who invited us
1599 def multipleLogin(self
):
1601 Called when the server says there has been another login
1602 under our account, the server should disconnect us right away.
1606 def serverGoingDown(self
):
1608 Called when the server has notified us that it is going down for
1615 def changeStatus(self
, status
):
1617 Change my current status. This method will add
1618 a default callback to the returned Deferred
1619 which will update the status attribute of the
1622 @param status: 3-letter status code (as defined by
1623 the STATUS_* constants)
1624 @return: A Deferred, the callback of which will be
1625 fired when the server confirms the change
1626 of status. The callback argument will be
1627 a tuple with the new status code as the
1631 id, d
= self
._createIDMapping
()
1632 self
.sendLine("CHG %s %s %s %s" % (id, status
, str(MSNContact
.MSNC1 | MSNContact
.MSNC2 | MSNContact
.MSNC3 | MSNContact
.MSNC4
), quote(self
.msnobj
.text
)))
1634 self
.factory
.status
= r
[0]
1636 return d
.addCallback(_cb
)
1638 def setPrivacyMode(self
, privLevel
):
1640 Set my privacy mode on the server.
1643 This only keeps the current privacy setting on
1644 the server for later retrieval, it does not
1645 effect the way the server works at all.
1647 @param privLevel: This parameter can be true, in which
1648 case the server will keep the state as
1649 'al' which the official client interprets
1650 as -> allow messages from only users on
1651 the allow list. Alternatively it can be
1652 false, in which case the server will keep
1653 the state as 'bl' which the official client
1654 interprets as -> allow messages from all
1655 users except those on the block list.
1657 @return: A Deferred, the callback of which will be fired when
1658 the server replies with the new privacy setting.
1659 The callback argument will be a tuple, the only element
1660 of which being either 'al' or 'bl' (the new privacy setting).
1663 id, d
= self
._createIDMapping
()
1664 if privLevel
: self
.sendLine("BLP %s AL" % id)
1665 else: self
.sendLine("BLP %s BL" % id)
1670 Used for keeping an up-to-date contact list.
1671 A callback is added to the returned Deferred
1672 that updates the contact list on the factory
1673 and also sets my state to STATUS_ONLINE.
1676 This is called automatically upon signing
1677 in using the version attribute of
1678 factory.contacts, so you may want to persist
1679 this object accordingly. Because of this there
1680 is no real need to ever call this method
1683 @return: A Deferred, the callback of which will be
1684 fired when the server sends an adequate reply.
1685 The callback argument will be a tuple with two
1686 elements, the new list (MSNContactList) and
1687 your current state (a dictionary). If the version
1688 you sent _was_ the latest list version, both elements
1689 will be None. To just request the list send a version of 0.
1692 self
._setState
('SYNC')
1693 id, d
= self
._createIDMapping
(data
=None)
1694 self
._setStateData
('synid',id)
1695 self
.sendLine("SYN %s %s %s" % (id, 0, 0))
1697 self
.changeStatus(STATUS_ONLINE
)
1698 if r
[0] is not None:
1699 self
.factory
.contacts
= r
[0]
1701 return d
.addCallback(_cb
)
1703 def setPhoneDetails(self
, phoneType
, value
):
1705 Set/change my phone numbers stored on the server.
1707 @param phoneType: phoneType can be one of the following
1708 constants - HOME_PHONE, WORK_PHONE,
1709 MOBILE_PHONE, HAS_PAGER.
1710 These are pretty self-explanatory, except
1711 maybe HAS_PAGER which refers to whether or
1712 not you have a pager.
1713 @param value: for all of the *_PHONE constants the value is a
1714 phone number (str), for HAS_PAGER accepted values
1715 are 'Y' (for yes) and 'N' (for no).
1717 @return: A Deferred, the callback for which will be fired when
1718 the server confirms the change has been made. The
1719 callback argument will be a tuple with 2 elements, the
1720 first being the new list version (int) and the second
1721 being the new phone number value (str).
1723 raise "ProbablyDoesntWork"
1724 # XXX: Add a default callback which updates
1725 # factory.contacts.version and the relevant phone
1727 id, d
= self
._createIDMapping
()
1728 self
.sendLine("PRP %s %s %s" % (id, phoneType
, quote(value
)))
1731 def addListGroup(self
, name
):
1733 Used to create a new list group.
1734 A default callback is added to the
1735 returned Deferred which updates the
1736 contacts attribute of the factory.
1738 @param name: The desired name of the new group.
1740 @return: A Deferred, the callbacck for which will be called
1741 when the server clarifies that the new group has been
1742 created. The callback argument will be a tuple with 3
1743 elements: the new list version (int), the new group name
1744 (str) and the new group ID (int).
1747 raise "ProbablyDoesntWork"
1748 id, d
= self
._createIDMapping
()
1749 self
.sendLine("ADG %s %s 0" % (id, quote(name
)))
1751 if self
.factory
.contacts
:
1752 self
.factory
.contacts
.version
= r
[0]
1753 self
.factory
.contacts
.setGroup(r
[1], r
[2])
1755 return d
.addCallback(_cb
)
1757 def remListGroup(self
, groupID
):
1759 Used to remove a list group.
1760 A default callback is added to the
1761 returned Deferred which updates the
1762 contacts attribute of the factory.
1764 @param groupID: the ID of the desired group to be removed.
1766 @return: A Deferred, the callback for which will be called when
1767 the server clarifies the deletion of the group.
1768 The callback argument will be a tuple with 2 elements:
1769 the new list version (int) and the group ID (int) of
1773 raise "ProbablyDoesntWork"
1774 id, d
= self
._createIDMapping
()
1775 self
.sendLine("RMG %s %s" % (id, groupID
))
1777 self
.factory
.contacts
.version
= r
[0]
1778 self
.factory
.contacts
.remGroup(r
[1])
1780 return d
.addCallback(_cb
)
1782 def renameListGroup(self
, groupID
, newName
):
1784 Used to rename an existing list group.
1785 A default callback is added to the returned
1786 Deferred which updates the contacts attribute
1789 @param groupID: the ID of the desired group to rename.
1790 @param newName: the desired new name for the group.
1792 @return: A Deferred, the callback for which will be called
1793 when the server clarifies the renaming.
1794 The callback argument will be a tuple of 3 elements,
1795 the new list version (int), the group id (int) and
1796 the new group name (str).
1799 raise "ProbablyDoesntWork"
1800 id, d
= self
._createIDMapping
()
1801 self
.sendLine("REG %s %s %s 0" % (id, groupID
, quote(newName
)))
1803 self
.factory
.contacts
.version
= r
[0]
1804 self
.factory
.contacts
.setGroup(r
[1], r
[2])
1806 return d
.addCallback(_cb
)
1808 def addContact(self
, listType
, userHandle
):
1810 Used to add a contact to the desired list.
1811 A default callback is added to the returned
1812 Deferred which updates the contacts attribute of
1813 the factory with the new contact information.
1814 If you are adding a contact to the forward list
1815 and you want to associate this contact with multiple
1816 groups then you will need to call this method for each
1817 group you would like to add them to, changing the groupID
1818 parameter. The default callback will take care of updating
1819 the group information on the factory's contact list.
1821 @param listType: (as defined by the *_LIST constants)
1822 @param userHandle: the user handle (passport) of the contact
1825 @return: A Deferred, the callback for which will be called when
1826 the server has clarified that the user has been added.
1827 The callback argument will be a tuple with 4 elements:
1828 the list type, the contact's user handle, the new list
1829 version, and the group id (if relevant, otherwise it
1833 id, d
= self
._createIDMapping
()
1834 try: # Make sure the contact isn't actually on the list
1835 if self
.factory
.contacts
.getContact(userHandle
).lists
& listType
: return
1836 except AttributeError: pass
1837 listType
= listIDToCode
[listType
].upper()
1838 if listType
== "FL":
1839 self
.sendLine("ADC %s %s N=%s F=%s" % (id, listType
, userHandle
, userHandle
))
1841 self
.sendLine("ADC %s %s N=%s" % (id, listType
, userHandle
))
1844 if not self
.factory
: return
1845 c
= self
.factory
.contacts
.getContact(r
[2])
1847 c
= MSNContact(userGuid
=r
[1], userHandle
=r
[2], screenName
=r
[3])
1848 self
.factory
.contacts
.addContact(c
)
1849 #if r[3]: c.groups.append(r[3])
1852 return d
.addCallback(_cb
)
1854 def remContact(self
, listType
, userHandle
):
1856 Used to remove a contact from the desired list.
1857 A default callback is added to the returned deferred
1858 which updates the contacts attribute of the factory
1859 to reflect the new contact information.
1861 @param listType: (as defined by the *_LIST constants)
1862 @param userHandle: the user handle (passport) of the
1863 contact being removed
1865 @return: A Deferred, the callback for which will be called when
1866 the server has clarified that the user has been removed.
1867 The callback argument will be a tuple of 3 elements:
1868 the list type, the contact's user handle and the group ID
1869 (if relevant, otherwise it will be None)
1872 id, d
= self
._createIDMapping
()
1873 try: # Make sure the contact is actually on this list
1874 if not (self
.factory
.contacts
.getContact(userHandle
).lists
& listType
): return
1875 except AttributeError: return
1876 listType
= listIDToCode
[listType
].upper()
1877 if listType
== "FL":
1879 c
= self
.factory
.contacts
.getContact(userHandle
)
1880 userGuid
= c
.userGuid
1881 except AttributeError: return
1882 self
.sendLine("REM %s FL %s" % (id, userGuid
))
1884 self
.sendLine("REM %s %s %s" % (id, listType
, userHandle
))
1887 if listType
== "FL":
1888 r
= (r
[0], userHandle
, r
[2]) # make sure we always get a userHandle
1889 l
= self
.factory
.contacts
1890 c
= l
.getContact(r
[1])
1894 if group
: # they may not have been removed from the list
1895 c
.groups
.remove(group
)
1896 if c
.groups
: shouldRemove
= 0
1898 c
.removeFromList(r
[0])
1899 if c
.lists
== 0: l
.remContact(c
.userHandle
)
1901 return d
.addCallback(_cb
)
1903 def changeScreenName(self
, newName
):
1905 Used to change your current screen name.
1906 A default callback is added to the returned
1907 Deferred which updates the screenName attribute
1908 of the factory and also updates the contact list
1911 @param newName: the new screen name
1913 @return: A Deferred, the callback for which will be called
1914 when the server acknowledges the change.
1915 The callback argument will be an empty tuple.
1918 id, d
= self
._createIDMapping
()
1919 self
.sendLine("PRP %s MFN %s" % (id, quote(newName
)))
1921 self
.factory
.screenName
= newName
1923 return d
.addCallback(_cb
)
1925 def changePersonalMessage(self
, personal
):
1927 Used to change your personal message.
1929 @param personal: the new screen name
1931 @return: A Deferred, the callback for which will be called
1932 when the server acknowledges the change.
1933 The callback argument will be a tuple of 1 element,
1934 the personal message.
1937 id, d
= self
._createIDMapping
()
1940 data
= "<Data><PSM>" + personal
+ "</PSM><CurrentMedia></CurrentMedia></Data>"
1941 self
.sendLine("UUX %s %s" % (id, len(data
)))
1942 self
.transport
.write(data
)
1944 self
.factory
.personal
= personal
1946 return d
.addCallback(_cb
)
1948 def changeAvatar(self
, imageData
, push
):
1950 Used to change the avatar that other users see.
1952 @param imageData: the PNG image data to set as the avatar
1953 @param push : whether to push the update to the server
1954 (it will otherwise be sent with the next
1957 @return: If push==True, a Deferred, the callback for which
1958 will be called when the server acknowledges the change.
1959 The callback argument will be the same as for changeStatus.
1962 if self
.msnobj
and imageData
== self
.msnobj
.imageData
: return
1964 self
.msnobj
.setData(self
.factory
.userHandle
, imageData
)
1966 self
.msnobj
.setNull()
1967 if push
: return self
.changeStatus(self
.factory
.status
) # Push to server
1970 def requestSwitchboardServer(self
):
1972 Used to request a switchboard server to use for conversations.
1974 @return: A Deferred, the callback for which will be called when
1975 the server responds with the switchboard information.
1976 The callback argument will be a tuple with 3 elements:
1977 the host of the switchboard server, the port and a key
1978 used for logging in.
1981 id, d
= self
._createIDMapping
()
1982 self
.sendLine("XFR %s SB" % id)
1987 Used to log out of the notification server.
1988 After running the method the server is expected
1989 to close the connection.
1992 if self
.pingCheckTask
:
1993 self
.pingCheckTask
.stop()
1994 self
.pingCheckTask
= None
1995 self
.factory
.stopTrying()
1996 self
.sendLine("OUT")
1997 self
.transport
.loseConnection()
1999 class NotificationFactory(ReconnectingClientFactory
):
2001 Factory for the NotificationClient protocol.
2002 This is basically responsible for keeping
2003 the state of the client and thus should be used
2004 in a 1:1 situation with clients.
2006 @ivar contacts: An MSNContactList instance reflecting
2007 the current contact list -- this is
2008 generally kept up to date by the default
2010 @ivar userHandle: The client's userHandle, this is expected
2011 to be set by the client and is used by the
2012 protocol (for logging in etc).
2013 @ivar screenName: The client's current screen-name -- this is
2014 generally kept up to date by the default
2016 @ivar password: The client's password -- this is (obviously)
2017 expected to be set by the client.
2018 @ivar passportServer: This must point to an msn passport server
2019 (the whole URL is required)
2020 @ivar status: The status of the client -- this is generally kept
2021 up to date by the default command handlers
2022 @ivar maxRetries: The number of times the factory will reconnect
2023 if the connection dies because of a network error.
2030 passportServer
= 'https://nexus.passport.com/rdr/pprdr.asp'
2032 protocol
= NotificationClient
2036 class SwitchboardClient(MSNEventBase
):
2038 This class provides support for clients connecting to a switchboard server.
2040 Switchboard servers are used for conversations with other people
2041 on the MSN network. This means that the number of conversations at
2042 any given time will be directly proportional to the number of
2043 connections to varioius switchboard servers.
2045 MSN makes no distinction between single and group conversations,
2046 so any number of users may be invited to join a specific conversation
2047 taking place on a switchboard server.
2049 @ivar key: authorization key, obtained when receiving
2050 invitation / requesting switchboard server.
2051 @ivar userHandle: your user handle (passport)
2052 @ivar sessionID: unique session ID, used if you are replying
2053 to a switchboard invitation
2054 @ivar reply: set this to 1 in connectionMade or before to signifiy
2055 that you are replying to a switchboard invitation.
2056 @ivar msnobj: the MSNObject for the user's avatar. So that the
2057 switchboard can distribute it to anyone who asks.
2069 MSNEventBase
.__init
__(self
)
2070 self
.pendingUsers
= {}
2071 self
.cookies
= {'iCookies' : {}} # will maybe be moved to a factory in the future
2074 def connectionMade(self
):
2075 MSNEventBase
.connectionMade(self
)
2078 def connectionLost(self
, reason
):
2079 self
.cookies
['iCookies'] = {}
2080 MSNEventBase
.connectionLost(self
, reason
)
2082 def _sendInit(self
):
2084 send initial data based on whether we are replying to an invitation
2087 id = self
._nextTransactionID
()
2089 self
.sendLine("USR %s %s %s" % (id, self
.userHandle
, self
.key
))
2091 self
.sendLine("ANS %s %s %s %s" % (id, self
.userHandle
, self
.key
, self
.sessionID
))
2093 def _newInvitationCookie(self
):
2095 if self
._iCookie
> 1000: self
._iCookie
= 1
2096 return self
._iCookie
2098 def _checkTyping(self
, message
, cTypes
):
2099 """ helper method for checkMessage """
2100 if 'text/x-msmsgscontrol' in cTypes
and message
.hasHeader('TypingUser'):
2101 self
.gotContactTyping(message
)
2104 def _checkFileInvitation(self
, message
, info
):
2105 """ helper method for checkMessage """
2106 if not info
.get('Application-GUID', '').upper() == MSN_MSNFTP_GUID
: return 0
2108 cookie
= info
['Invitation-Cookie']
2109 filename
= info
['Application-File']
2110 filesize
= int(info
['Application-FileSize'])
2111 connectivity
= (info
.get('Connectivity', 'n').lower() == 'y')
2113 log
.msg('Received munged file transfer request ... ignoring.')
2115 raise NotImplementedError
2116 self
.gotSendRequest(msnft
.MSNFTP_Receive(filename
, filesize
, message
.userHandle
, cookie
, connectivity
, self
))
2119 def _handleP2PMessage(self
, message
):
2120 """ helper method for msnslp messages (file transfer & avatars) """
2121 if not message
.getHeader("P2P-Dest") == self
.userHandle
: return
2122 packet
= message
.message
2123 binaryFields
= BinaryFields(packet
=packet
)
2124 if binaryFields
[5] == BinaryFields
.BYEGOT
:
2125 pass # Ignore the ACKs to SLP messages
2126 elif binaryFields
[0] != 0:
2127 slpLink
= self
.slpLinks
.get(binaryFields
[0])
2129 # Link has been killed. Ignore
2131 if slpLink
.remoteUser
== message
.userHandle
:
2132 slpLink
.handlePacket(packet
)
2133 elif binaryFields
[5] == BinaryFields
.ACK
:
2134 pass # Ignore the ACKs to SLP messages
2136 slpMessage
= MSNSLPMessage(packet
)
2138 # Always try and give a slpMessage to a slpLink first.
2139 # If none can be found, and it was INVITE, then create
2140 # one to handle the session.
2141 for slpLink
in self
.slpLinks
.values():
2142 if slpLink
.sessionGuid
== slpMessage
.sessionGuid
:
2143 slpLink
.handleSLPMessage(slpMessage
)
2146 slpLink
= None # Was not handled
2148 if not slpLink
and slpMessage
.method
== "INVITE":
2149 if slpMessage
.euf_guid
== MSN_MSNFTP_GUID
:
2150 context
= FileContext(slpMessage
.context
)
2151 slpLink
= SLPLink_FileReceive(remoteUser
=slpMessage
.fro
, switchboard
=self
, filename
=context
.filename
, filesize
=context
.filesize
, sessionID
=slpMessage
.sessionID
, sessionGuid
=slpMessage
.sessionGuid
, branch
=slpMessage
.branch
)
2152 self
.slpLinks
[slpMessage
.sessionID
] = slpLink
2153 self
.gotFileReceive(slpLink
)
2154 elif slpMessage
.euf_guid
== MSN_AVATAR_GUID
:
2155 # Check that we have an avatar to send
2157 slpLink
= SLPLink_AvatarSend(remoteUser
=slpMessage
.fro
, switchboard
=self
, filesize
=self
.msnobj
.size
, sessionID
=slpMessage
.sessionID
, sessionGuid
=slpMessage
.sessionGuid
)
2158 slpLink
.write(self
.msnobj
.imageData
)
2161 # They shouldn't have sent a request if we have
2162 # no avatar. So we'll just ignore them.
2163 # FIXME We should really send an error
2166 self
.slpLinks
[slpMessage
.sessionID
] = slpLink
2168 # Always need to ACK these packets if we can
2169 slpLink
.sendP2PACK(binaryFields
)
2172 def checkMessage(self
, message
):
2174 hook for detecting any notification type messages
2175 (e.g. file transfer)
2177 cTypes
= [s
.lstrip() for s
in message
.getHeader('Content-Type').split(';')]
2178 if self
._checkTyping
(message
, cTypes
): return 0
2179 # if 'text/x-msmsgsinvite' in cTypes:
2180 # header like info is sent as part of the message body.
2182 # for line in message.message.split('\r\n'):
2184 # key, val = line.split(':')
2185 # info[key] = val.lstrip()
2186 # except ValueError: continue
2187 # if self._checkFileInvitation(message, info): return 0
2188 elif 'application/x-msnmsgrp2p' in cTypes
:
2189 self
._handleP
2PMessage
(message
)
2194 def handle_USR(self
, params
):
2195 checkParamLen(len(params
), 4, 'USR')
2196 if params
[1] == "OK":
2200 def handle_CAL(self
, params
):
2201 checkParamLen(len(params
), 3, 'CAL')
2203 if params
[1].upper() == "RINGING":
2204 self
._fireCallback
(id, int(params
[2])) # session ID as parameter
2207 def handle_JOI(self
, params
):
2208 checkParamLen(len(params
), 2, 'JOI')
2209 self
.userJoined(params
[0], unquote(params
[1]))
2211 # users participating in the current chat
2212 def handle_IRO(self
, params
):
2213 checkParamLen(len(params
), 5, 'IRO')
2214 self
.pendingUsers
[params
[3]] = unquote(params
[4])
2215 if params
[1] == params
[2]:
2216 self
.gotChattingUsers(self
.pendingUsers
)
2217 self
.pendingUsers
= {}
2219 # finished listing users
2220 def handle_ANS(self
, params
):
2221 checkParamLen(len(params
), 2, 'ANS')
2222 if params
[1] == "OK":
2225 def handle_ACK(self
, params
):
2226 checkParamLen(len(params
), 1, 'ACK')
2227 self
._fireCallback
(int(params
[0]), None)
2229 def handle_NAK(self
, params
):
2230 checkParamLen(len(params
), 1, 'NAK')
2231 self
._fireCallback
(int(params
[0]), None)
2233 def handle_BYE(self
, params
):
2234 #checkParamLen(len(params), 1, 'BYE') # i've seen more than 1 param passed to this
2235 self
.userLeft(params
[0])
2241 called when all login details have been negotiated.
2242 Messages can now be sent, or new users invited.
2246 def gotChattingUsers(self
, users
):
2248 called after connecting to an existing chat session.
2250 @param users: A dict mapping user handles to screen names
2251 (current users taking part in the conversation)
2255 def userJoined(self
, userHandle
, screenName
):
2257 called when a user has joined the conversation.
2259 @param userHandle: the user handle (passport) of the user
2260 @param screenName: the screen name of the user
2264 def userLeft(self
, userHandle
):
2266 called when a user has left the conversation.
2268 @param userHandle: the user handle (passport) of the user.
2272 def gotMessage(self
, message
):
2274 called when we receive a message.
2276 @param message: the associated MSNMessage object
2280 def gotFileReceive(self
, fileReceive
):
2282 called when we receive a file send request from a contact.
2283 Default action is to reject the file.
2285 @param fileReceive: msnft.MSNFTReceive_Base instance
2287 fileReceive
.reject()
2290 def gotSendRequest(self
, fileReceive
):
2292 called when we receive a file send request from a contact
2294 @param fileReceive: msnft.MSNFTReceive_Base instance
2298 def gotContactTyping(self
, message
):
2300 called when we receive the special type of message notifying
2301 us that a contact is typing a message.
2303 @param message: the associated MSNMessage object
2309 def inviteUser(self
, userHandle
):
2311 used to invite a user to the current switchboard server.
2313 @param userHandle: the user handle (passport) of the desired user.
2315 @return: A Deferred, the callback for which will be called
2316 when the server notifies us that the user has indeed
2317 been invited. The callback argument will be a tuple
2318 with 1 element, the sessionID given to the invited user.
2319 I'm not sure if this is useful or not.
2322 id, d
= self
._createIDMapping
()
2323 self
.sendLine("CAL %s %s" % (id, userHandle
))
2326 def sendMessage(self
, message
):
2328 used to send a message.
2330 @param message: the corresponding MSNMessage object.
2332 @return: Depending on the value of message.ack.
2333 If set to MSNMessage.MESSAGE_ACK or
2334 MSNMessage.MESSAGE_NACK a Deferred will be returned,
2335 the callback for which will be fired when an ACK or
2336 NACK is received - the callback argument will be
2337 (None,). If set to MSNMessage.MESSAGE_ACK_NONE then
2338 the return value is None.
2341 if message
.ack
not in ('A','N','D'): id, d
= self
._nextTransactionID
(), None
2342 else: id, d
= self
._createIDMapping
()
2343 if message
.length
== 0: message
.length
= message
._calcMessageLen
()
2344 self
.sendLine("MSG %s %s %s" % (id, message
.ack
, message
.length
))
2345 # Apparently order matters with these
2346 orderMatters
= ("MIME-Version", "Content-Type", "Message-ID")
2347 for header
in orderMatters
:
2348 if message
.hasHeader(header
):
2349 self
.sendLine("%s: %s" % (header
, message
.getHeader(header
)))
2350 # send the rest of the headers
2351 for header
in [h
for h
in message
.headers
.items() if h
[0] not in orderMatters
]:
2352 self
.sendLine("%s: %s" % (header
[0], header
[1]))
2353 self
.transport
.write("\r\n")
2354 self
.transport
.write(message
.message
)
2355 if MESSAGEDEBUG
: log
.msg(message
.message
)
2358 def sendAvatarRequest(self
, msnContact
):
2360 used to request an avatar from a user in this switchboard
2363 @param msnContact: the msnContact object to request an avatar for
2365 @return: A Deferred, the callback for which will be called
2366 when the avatar transfer succeeds.
2367 The callback argument will be a tuple with one element,
2368 the PNG avatar data.
2370 if not msnContact
.msnobj
: return
2372 def bufferClosed(data
):
2374 buffer = StringBuffer(bufferClosed
)
2375 buffer.error
= lambda: None
2376 slpLink
= SLPLink_AvatarReceive(remoteUser
=msnContact
.userHandle
, switchboard
=self
, consumer
=buffer, context
=msnContact
.msnobj
.text
)
2377 self
.slpLinks
[slpLink
.sessionID
] = slpLink
2380 def sendFile(self
, msnContact
, filename
, filesize
):
2382 used to send a file to a contact.
2384 @param msnContact: the MSNContact object to send a file to.
2385 @param filename: the name of the file to send.
2386 @param filesize: the size of the file to send.
2388 @return: (fileSend, d) A FileSend object and a Deferred.
2389 The Deferred will pass one argument in a tuple,
2390 whether or not the transfer is accepted. If you
2391 receive a True, then you can call write() on the
2392 fileSend object to send your file. Call close()
2393 when the file is done.
2394 NOTE: You MUST write() exactly as much as you
2395 declare in filesize.
2397 if not msnContact
.userHandle
: return
2398 # FIXME, check msnContact.caps to see if we should use old-style
2399 fileSend
= SLPLink_FileSend(remoteUser
=msnContact
.userHandle
, switchboard
=self
, filename
=filename
, filesize
=filesize
)
2400 self
.slpLinks
[fileSend
.sessionID
] = fileSend
2401 return fileSend
, fileSend
.acceptDeferred
2403 def sendTypingNotification(self
):
2405 Used to send a typing notification. Upon receiving this
2406 message the official client will display a 'user is typing'
2407 message to all other users in the chat session for 10 seconds.
2408 You should send one of these every 5 seconds as long as the
2412 m
.ack
= m
.MESSAGE_ACK_NONE
2413 m
.setHeader('Content-Type', 'text/x-msmsgscontrol')
2414 m
.setHeader('TypingUser', self
.userHandle
)
2418 def sendFileInvitation(self
, fileName
, fileSize
):
2420 send an notification that we want to send a file.
2422 @param fileName: the file name
2423 @param fileSize: the file size
2425 @return: A Deferred, the callback of which will be fired
2426 when the user responds to this invitation with an
2427 appropriate message. The callback argument will be
2428 a tuple with 3 elements, the first being 1 or 0
2429 depending on whether they accepted the transfer
2430 (1=yes, 0=no), the second being an invitation cookie
2431 to identify your follow-up responses and the third being
2432 the message 'info' which is a dict of information they
2433 sent in their reply (this doesn't really need to be used).
2434 If you wish to proceed with the transfer see the
2435 sendTransferInfo method.
2437 cookie
= self
._newInvitationCookie
()
2440 m
.setHeader('Content-Type', 'text/x-msmsgsinvite; charset=UTF-8')
2441 m
.message
+= 'Application-Name: File Transfer\r\n'
2442 m
.message
+= 'Application-GUID: %s\r\n' % MSN_MSNFTP_GUID
2443 m
.message
+= 'Invitation-Command: INVITE\r\n'
2444 m
.message
+= 'Invitation-Cookie: %s\r\n' % str(cookie
)
2445 m
.message
+= 'Application-File: %s\r\n' % fileName
2446 m
.message
+= 'Application-FileSize: %s\r\n\r\n' % str(fileSize
)
2447 m
.ack
= m
.MESSAGE_ACK_NONE
2449 self
.cookies
['iCookies'][cookie
] = (d
, m
)
2452 def sendTransferInfo(self
, accept
, iCookie
, authCookie
, ip
, port
):
2454 send information relating to a file transfer session.
2456 @param accept: whether or not to go ahead with the transfer
2458 @param iCookie: the invitation cookie of previous replies
2459 relating to this transfer
2460 @param authCookie: the authentication cookie obtained from
2461 an FileSend instance
2463 @param port: the port on which an FileSend protocol is listening.
2466 m
.setHeader('Content-Type', 'text/x-msmsgsinvite; charset=UTF-8')
2467 m
.message
+= 'Invitation-Command: %s\r\n' % (accept
and 'ACCEPT' or 'CANCEL')
2468 m
.message
+= 'Invitation-Cookie: %s\r\n' % iCookie
2469 m
.message
+= 'IP-Address: %s\r\n' % ip
2470 m
.message
+= 'Port: %s\r\n' % port
2471 m
.message
+= 'AuthCookie: %s\r\n' % authCookie
2473 m
.ack
= m
.MESSAGE_NACK
2478 def __init__(self
, filename
, filesize
, userHandle
):
2479 self
.consumer
= None
2480 self
.finished
= False
2483 self
.filename
, self
.filesize
, self
.userHandle
= filename
, filesize
, userHandle
2486 raise NotImplementedError
2488 def accept(self
, consumer
):
2489 if self
.consumer
: raise "AlreadyAccepted"
2490 self
.consumer
= consumer
2491 for data
in self
.buffer:
2492 self
.consumer
.write(data
)
2495 self
.consumer
.close()
2497 self
.consumer
.error()
2499 def write(self
, data
):
2500 if self
.error
or self
.finished
:
2501 raise IOError, "Attempt to write in an invalid state"
2503 self
.consumer
.write(data
)
2505 self
.buffer.append(data
)
2508 self
.finished
= True
2510 self
.consumer
.close()
2513 """ Represents the Context field for P2P file transfers """
2514 def __init__(self
, data
=""):
2522 if MSNP2PDEBUG
: log
.msg("FileContext packing:", self
.filename
, self
.filesize
)
2523 data
= struct
.pack("<LLQL", 638, 0x03, self
.filesize
, 0x01)
2524 data
= data
[:-1] # Uck, weird, but it works
2525 data
+= utf16net(self
.filename
)
2526 data
= ljust(data
, 570, '\0')
2527 data
+= struct
.pack("<L", 0xFFFFFFFFL
)
2528 data
= ljust(data
, 638, '\0')
2531 def parse(self
, packet
):
2532 self
.filesize
= struct
.unpack("<Q", packet
[8:16])[0]
2533 chunk
= packet
[19:540]
2534 chunk
= chunk
[:chunk
.find('\x00\x00')]
2535 self
.filename
= unicode((codecs
.BOM_UTF16_BE
+ chunk
).decode("utf-16"))
2536 if MSNP2PDEBUG
: log
.msg("FileContext parsed:", self
.filesize
, self
.filename
)
2540 """ Utility class for the binary header & footer in p2p messages """
2549 def __init__(self
, fields
=None, packet
=None):
2551 self
.fields
= fields
2553 self
.fields
= [0] * 10
2555 self
.unpackFields(packet
)
2557 def __getitem__(self
, key
):
2558 return self
.fields
[key
]
2560 def __setitem__(self
, key
, value
):
2561 self
.fields
[key
] = value
2563 def unpackFields(self
, packet
):
2564 self
.fields
= struct
.unpack("<LLQQLLLLQ", packet
[0:48])
2565 self
.fields
+= struct
.unpack(">L", packet
[len(packet
)-4:])
2567 out
= "Unpacked fields: "
2568 for i
in self
.fields
:
2572 def packHeaders(self
):
2573 f
= tuple(self
.fields
)
2575 out
= "Packed fields: "
2576 for i
in self
.fields
:
2579 return struct
.pack("<LLQQLLLLQ", f
[0], f
[1], f
[2], f
[3], f
[4], f
[5], f
[6], f
[7], f
[8])
2581 def packFooter(self
):
2582 return struct
.pack(">L", self
.fields
[9])
2585 class MSNSLPMessage
:
2586 """ Representation of a single MSNSLP message """
2587 def __init__(self
, packet
=None):
2594 self
.sessionGuid
= ""
2595 self
.sessionID
= None
2597 self
.data
= "\r\n" + chr(0)
2601 def create(self
, method
=None, status
=None, to
=None, fro
=None, branch
=None, cseq
=0, sessionGuid
=None, data
=None):
2602 self
.method
= method
2603 self
.status
= status
2606 self
.branch
= branch
2608 self
.sessionGuid
= sessionGuid
2609 if data
: self
.data
= data
2611 def setData(self
, ctype
, data
):
2614 order
= ["EUF-GUID", "SessionID", "AppID", "Context", "Bridge", "Listening","Bridges", "NetID", "Conn-Type", "UPnPNat", "ICF", "Hashed-Nonce"]
2616 if key
== "Context" and data
.has_key(key
):
2617 s
.append("Context: %s\r\n" % b64enc(data
[key
]))
2618 elif data
.has_key(key
):
2619 s
.append("%s: %s\r\n" % (key
, str(data
[key
])))
2620 s
.append("\r\n"+chr(0))
2622 self
.data
= "".join(s
)
2626 if s
.find("MSNSLP/1.0") < 0: return
2628 lines
= s
.split("\r\n")
2630 # Get the MSNSLP method or status
2631 msnslp
= lines
[0].split(" ")
2632 if MSNP2PDEBUG
: log
.msg("Parsing MSNSLPMessage %s %s" % (len(s
), s
))
2633 if msnslp
[0] in ("INVITE", "BYE"):
2634 self
.method
= msnslp
[0].strip()
2636 self
.status
= msnslp
[1].strip()
2638 lines
.remove(lines
[0])
2641 line
= line
.split(":")
2642 if len(line
) < 1: continue
2644 if len(line
) > 2 and line
[0] == "To":
2645 self
.to
= line
[2][:line
[2].find('>')]
2646 elif len(line
) > 2 and line
[0] == "From":
2647 self
.fro
= line
[2][:line
[2].find('>')]
2648 elif line
[0] == "Call-ID":
2649 self
.sessionGuid
= line
[1].strip()
2650 elif line
[0] == "CSeq":
2651 self
.cseq
= int(line
[1].strip())
2652 elif line
[0] == "SessionID":
2653 self
.sessionID
= int(line
[1].strip())
2654 elif line
[0] == "EUF-GUID":
2655 self
.euf_guid
= line
[1].strip()
2656 elif line
[0] == "Content-Type":
2657 self
.ctype
= line
[1].strip()
2658 elif line
[0] == "Context":
2659 self
.context
= b64dec(line
[1])
2660 elif line
[0] == "Via":
2661 self
.branch
= line
[1].split(";")[1].split("=")[1].strip()
2664 log
.msg("Error parsing MSNSLP message.")
2670 s
.append("%s MSNMSGR:%s MSNSLP/1.0\r\n" % (self
.method
, self
.to
))
2672 if self
.status
== "200": status
= "200 OK"
2673 elif self
.status
== "603": status
= "603 Decline"
2674 s
.append("MSNSLP/1.0 %s\r\n" % status
)
2675 s
.append("To: <msnmsgr:%s>\r\n" % self
.to
)
2676 s
.append("From: <msnmsgr:%s>\r\n" % self
.fro
)
2677 s
.append("Via: MSNSLP/1.0/TLP ;branch=%s\r\n" % self
.branch
)
2678 s
.append("CSeq: %s \r\n" % str(self
.cseq
))
2679 s
.append("Call-ID: %s\r\n" % self
.sessionGuid
)
2680 s
.append("Max-Forwards: 0\r\n")
2681 s
.append("Content-Type: %s\r\n" % self
.ctype
)
2682 s
.append("Content-Length: %s\r\n\r\n" % len(self
.data
))
2687 """ Utility for handling the weird sequence IDs in p2p messages """
2688 def __init__(self
, baseID
=None):
2690 self
.baseID
= baseID
2692 self
.baseID
= random
.randint(1000, sys
.maxint
)
2696 return p2pseq(self
.pos
) + self
.baseID
2703 class StringBuffer(StringIO
.StringIO
):
2704 def __init__(self
, notifyFunc
=None):
2705 self
.notifyFunc
= notifyFunc
2706 StringIO
.StringIO
.__init
__(self
)
2710 self
.notifyFunc(self
.getvalue())
2711 self
.notifyFunc
= None
2712 StringIO
.StringIO
.close(self
)
2716 def __init__(self
, remoteUser
, switchboard
, sessionID
, sessionGuid
):
2719 sessionID
= random
.randint(1000, sys
.maxint
)
2721 sessionGuid
= random_guid()
2722 self
.remoteUser
= remoteUser
2723 self
.switchboard
= switchboard
2724 self
.sessionID
= sessionID
2725 self
.sessionGuid
= sessionGuid
2726 self
.seqID
= SeqID()
2729 if MSNP2PDEBUG
: log
.msg("killLink")
2731 if MSNP2PDEBUG
: log
.msg("killLink - kill()")
2732 if not self
.switchboard
: return
2733 del self
.switchboard
.slpLinks
[self
.sessionID
]
2734 self
.switchboard
= None
2735 # This is so that handleP2PMessage can still use the SLPLink
2736 # one last time, for ACKing BYEs and 601s.
2737 reactor
.callLater(0, kill
)
2739 def warn(self
, text
):
2740 log
.msg("Warning in transfer: %s %s" % (self
, text
))
2742 def sendP2PACK(self
, ackHeaders
):
2743 binaryFields
= BinaryFields()
2744 binaryFields
[0] = ackHeaders
[0]
2745 binaryFields
[1] = self
.seqID
.next()
2746 binaryFields
[3] = ackHeaders
[3]
2747 binaryFields
[5] = BinaryFields
.ACK
2748 binaryFields
[6] = ackHeaders
[1]
2749 binaryFields
[7] = ackHeaders
[6]
2750 binaryFields
[8] = ackHeaders
[3]
2751 self
.sendP2PMessage(binaryFields
, "")
2753 def sendSLPMessage(self
, cmd
, ctype
, data
, branch
=None):
2754 msg
= MSNSLPMessage()
2756 msg
.create(status
=cmd
, to
=self
.remoteUser
, fro
=self
.switchboard
.userHandle
, branch
=branch
, cseq
=1, sessionGuid
=self
.sessionGuid
)
2758 msg
.create(method
=cmd
, to
=self
.remoteUser
, fro
=self
.switchboard
.userHandle
, branch
=random_guid(), cseq
=0, sessionGuid
=self
.sessionGuid
)
2759 msg
.setData(ctype
, data
)
2761 binaryFields
= BinaryFields()
2762 binaryFields
[1] = self
.seqID
.next()
2763 binaryFields
[3] = len(msgStr
)
2764 binaryFields
[4] = binaryFields
[3]
2765 binaryFields
[6] = random
.randint(1000, sys
.maxint
)
2766 self
.sendP2PMessage(binaryFields
, msgStr
)
2768 def sendP2PMessage(self
, binaryFields
, msgStr
):
2769 packet
= binaryFields
.packHeaders() + msgStr
+ binaryFields
.packFooter()
2771 message
= MSNMessage(message
=packet
)
2772 message
.setHeader("Content-Type", "application/x-msnmsgrp2p")
2773 message
.setHeader("P2P-Dest", self
.remoteUser
)
2774 message
.ack
= MSNMessage
.MESSAGE_ACK_FAT
2775 self
.switchboard
.sendMessage(message
)
2777 def handleSLPMessage(self
, slpMessage
):
2778 raise NotImplementedError
2784 class SLPLink_Send(SLPLink
):
2785 def __init__(self
, remoteUser
, switchboard
, filesize
, sessionID
=None, sessionGuid
=None):
2786 SLPLink
.__init
__(self
, remoteUser
, switchboard
, sessionID
, sessionGuid
)
2787 self
.handlePacket
= None
2789 self
.filesize
= filesize
2792 def send_dataprep(self
):
2793 if MSNP2PDEBUG
: log
.msg("send_dataprep")
2794 binaryFields
= BinaryFields()
2795 binaryFields
[0] = self
.sessionID
2796 binaryFields
[1] = self
.seqID
.next()
2799 binaryFields
[6] = random
.randint(1000, sys
.maxint
)
2801 self
.sendP2PMessage(binaryFields
, chr(0) * 4)
2803 def write(self
, data
):
2804 if MSNP2PDEBUG
: log
.msg("write")
2806 data
= self
.data
+ data
2810 if i
+ 1202 < length
:
2811 self
._writeChunk
(data
[i
:i
+1202])
2814 self
.data
= data
[i
:]
2817 def _writeChunk(self
, chunk
):
2818 if MSNP2PDEBUG
: log
.msg("writing chunk")
2819 binaryFields
= BinaryFields()
2820 binaryFields
[0] = self
.sessionID
2821 if self
.offset
== 0:
2822 binaryFields
[1] = self
.seqID
.next()
2824 binaryFields
[1] = self
.seqID
.get()
2825 binaryFields
[2] = self
.offset
2826 binaryFields
[3] = self
.filesize
2827 binaryFields
[4] = len(chunk
)
2828 binaryFields
[5] = self
.dataFlag
2829 binaryFields
[6] = random
.randint(1000, sys
.maxint
)
2831 self
.offset
+= len(chunk
)
2832 self
.sendP2PMessage(binaryFields
, chunk
)
2836 self
._writeChunk
(self
.data
)
2841 # FIXME, should send 601 or something
2843 class SLPLink_FileSend(SLPLink_Send
):
2844 def __init__(self
, remoteUser
, switchboard
, filename
, filesize
):
2845 SLPLink_Send
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, filesize
=filesize
)
2846 self
.dataFlag
= BinaryFields
.DATAFT
2847 # Send invite & wait for 200OK before sending dataprep
2848 context
= FileContext()
2849 context
.filename
= filename
2850 context
.filesize
= filesize
2851 data
= {"EUF-GUID" : MSN_MSNFTP_GUID
,\
2852 "SessionID": self
.sessionID
,\
2854 "Context" : context
.pack() }
2855 self
.sendSLPMessage("INVITE", "application/x-msnmsgr-sessionreqbody", data
)
2856 self
.acceptDeferred
= Deferred()
2858 def handleSLPMessage(self
, slpMessage
):
2859 if slpMessage
.status
== "200":
2860 if slpMessage
.ctype
== "application/x-msnmsgr-sessionreqbody":
2861 data
= {"Bridges" : "TRUDPv1 TCPv1",\
2863 "Conn-Type" : "Firewall",\
2864 "UPnPNat" : "false",\
2866 #"Hashed-Nonce": random_guid()}
2867 self
.sendSLPMessage("INVITE", "application/x-msnmsgr-transreqbody", data
)
2868 elif slpMessage
.ctype
== "application/x-msnmsgr-transrespbody":
2869 self
.acceptDeferred
.callback((True,))
2870 self
.handlePacket
= self
.wait_data_ack
2872 if slpMessage
.status
== "603":
2873 self
.acceptDeferred
.callback((False,))
2874 if MSNP2PDEBUG
: log
.msg("SLPLink is over due to decline, error or BYE")
2878 def wait_data_ack(self
, packet
):
2879 if MSNP2PDEBUG
: log
.msg("wait_data_ack")
2880 binaryFields
= BinaryFields()
2881 binaryFields
.unpackFields(packet
)
2883 if binaryFields
[5] != BinaryFields
.ACK
:
2884 self
.warn("field5," + str(binaryFields
[5]))
2887 self
.sendSLPMessage("BYE", "application/x-msnmsgr-sessionclosebody", {})
2888 self
.handlePacket
= None
2891 self
.handlePacket
= self
.wait_data_ack
2892 SLPLink_Send
.close(self
)
2895 class SLPLink_AvatarSend(SLPLink_Send
):
2896 def __init__(self
, remoteUser
, switchboard
, filesize
, sessionID
=None, sessionGuid
=None):
2897 SLPLink_Send
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, filesize
=filesize
, sessionID
=sessionID
, sessionGuid
=sessionGuid
)
2898 self
.dataFlag
= BinaryFields
.DATA
2899 self
.sendSLPMessage("200", "application/x-msnmsgr-sessionreqbody", {"SessionID":self
.sessionID
})
2900 self
.send_dataprep()
2901 self
.handlePacket
= lambda packet
: None
2903 def handleSLPMessage(self
, slpMessage
):
2904 if MSNP2PDEBUG
: log
.msg("BYE or error")
2908 SLPLink_Send
.close(self
)
2909 # Keep the link open to wait for a BYE
2911 class SLPLink_Receive(SLPLink
):
2912 def __init__(self
, remoteUser
, switchboard
, consumer
, context
=None, sessionID
=None, sessionGuid
=None):
2913 SLPLink
.__init
__(self
, remoteUser
, switchboard
, sessionID
, sessionGuid
)
2914 self
.handlePacket
= None
2915 self
.consumer
= consumer
2918 def wait_dataprep(self
, packet
):
2919 if MSNP2PDEBUG
: log
.msg("wait_dataprep")
2920 binaryFields
= BinaryFields()
2921 binaryFields
.unpackFields(packet
)
2923 if binaryFields
[3] != 4:
2924 self
.warn("field3," + str(binaryFields
[3]))
2926 if binaryFields
[4] != 4:
2927 self
.warn("field4," + str(binaryFields
[4]))
2929 # Just ignore the footer
2930 #if binaryFields[9] != 1:
2931 # self.warn("field9," + str(binaryFields[9]))
2934 self
.sendP2PACK(binaryFields
)
2935 self
.handlePacket
= self
.wait_data
2937 def wait_data(self
, packet
):
2938 if MSNP2PDEBUG
: log
.msg("wait_data")
2939 binaryFields
= BinaryFields()
2940 binaryFields
.unpackFields(packet
)
2942 if binaryFields
[5] != self
.dataFlag
:
2943 self
.warn("field5," + str(binaryFields
[5]))
2945 # Just ignore the footer
2946 #if binaryFields[9] != 1:
2947 # self.warn("field9," + str(binaryFields[9]))
2949 offset
= binaryFields
[2]
2950 total
= binaryFields
[3]
2951 length
= binaryFields
[4]
2953 data
= packet
[48:-4]
2954 if offset
!= self
.pos
:
2955 self
.warn("Received packet out of order")
2956 self
.consumer
.error()
2958 if len(data
) != length
:
2959 self
.warn("Received bad length of slp")
2960 self
.consumer
.error()
2965 self
.consumer
.write(str(data
))
2967 if self
.pos
== total
:
2968 self
.sendP2PACK(binaryFields
)
2969 self
.consumer
.close()
2970 self
.handlePacket
= None
2973 def doFinished(self
):
2974 raise NotImplementedError
2977 class SLPLink_FileReceive(SLPLink_Receive
, FileReceive
):
2978 def __init__(self
, remoteUser
, switchboard
, filename
, filesize
, sessionID
, sessionGuid
, branch
):
2979 SLPLink_Receive
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, consumer
=self
, sessionID
=sessionID
, sessionGuid
=sessionGuid
)
2980 self
.dataFlag
= BinaryFields
.DATAFT
2981 self
.initialBranch
= branch
2982 FileReceive
.__init
__(self
, filename
, filesize
, remoteUser
)
2985 # Send a 603 decline
2986 if not self
.switchboard
: return
2987 self
.sendSLPMessage("603", "application/x-msnmsgr-sessionreqbody", {"SessionID":self
.sessionID
}, branch
=self
.initialBranch
)
2990 def accept(self
, consumer
):
2991 FileReceive
.accept(self
, consumer
)
2992 if not self
.switchboard
: return
2993 self
.sendSLPMessage("200", "application/x-msnmsgr-sessionreqbody", {"SessionID":self
.sessionID
}, branch
=self
.initialBranch
)
2994 self
.handlePacket
= self
.wait_data
# Moved here because sometimes the second INVITE seems to be skipped
2996 def handleSLPMessage(self
, slpMessage
):
2997 if slpMessage
.method
== "INVITE": # The second invite
2998 data
= {"Bridge" : "TCPv1",\
2999 "Listening" : "false",\
3000 "Hashed-Nonce": "{00000000-0000-0000-0000-000000000000}"}
3001 self
.sendSLPMessage("200", "application/x-msnmsgr-transrespbody", data
, branch
=slpMessage
.branch
)
3002 # self.handlePacket = self.wait_data # Moved up
3004 if MSNP2PDEBUG
: log
.msg("It's either a BYE or an error")
3006 # FIXME, do some error handling if it was an error
3008 def doFinished(self
):
3009 #self.sendSLPMessage("BYE", "application/x-msnmsgr-sessionclosebody", {})
3011 # Wait for BYE? #FIXME
3014 class SLPLink_AvatarReceive(SLPLink_Receive
):
3015 def __init__(self
, remoteUser
, switchboard
, consumer
, context
):
3016 SLPLink_Receive
.__init
__(self
, remoteUser
=remoteUser
, switchboard
=switchboard
, consumer
=consumer
, context
=context
)
3017 self
.dataFlag
= BinaryFields
.DATA
3018 data
= {"EUF-GUID" : MSN_AVATAR_GUID
,\
3019 "SessionID": self
.sessionID
,\
3021 "Context" : context
}
3022 self
.sendSLPMessage("INVITE", "application/x-msnmsgr-sessionreqbody", data
)
3023 self
.handlePacket
= self
.wait_dataprep
3025 def handleSLPMessage(self
, slpMessage
):
3026 if slpMessage
.method
== "INVITE": # The second invite
3027 data
= {"Bridge" : "TCPv1",\
3028 "Listening" : "false",\
3029 "Hashed-Nonce": "{00000000-0000-0000-0000-000000000000}"}
3030 self
.sendSLPMessage("200", "application/x-msnmsgr-transrespbody", data
, branch
=slpMessage
.branch
)
3031 elif slpMessage
.status
== "200":
3033 #self.handlePacket = self.wait_dataprep # Moved upwards
3035 if MSNP2PDEBUG
: log
.msg("SLPLink is over due to error or BYE")
3038 def doFinished(self
):
3039 self
.sendSLPMessage("BYE", "application/x-msnmsgr-sessionclosebody", {})
3041 # mapping of error codes to error messages
3044 200 : "Syntax error",
3045 201 : "Invalid parameter",
3046 205 : "Invalid user",
3047 206 : "Domain name missing",
3048 207 : "Already logged in",
3049 208 : "Invalid username",
3050 209 : "Invalid screen name",
3051 210 : "User list full",
3052 215 : "User already there",
3053 216 : "User already on list",
3054 217 : "User not online",
3055 218 : "Already in mode",
3056 219 : "User is in the opposite list",
3057 223 : "Too many groups",
3058 224 : "Invalid group",
3059 225 : "User not in group",
3060 229 : "Group name too long",
3061 230 : "Cannot remove group 0",
3062 231 : "Invalid group",
3063 280 : "Switchboard failed",
3064 281 : "Transfer to switchboard failed",
3066 300 : "Required field missing",
3067 301 : "Too many FND responses",
3068 302 : "Not logged in",
3070 400 : "Message not allowed",
3071 402 : "Error accessing contact list",
3072 403 : "Error accessing contact list",
3074 500 : "Internal server error",
3075 501 : "Database server error",
3076 502 : "Command disabled",
3077 510 : "File operation failed",
3078 520 : "Memory allocation failed",
3079 540 : "Wrong CHL value sent to server",
3081 600 : "Server is busy",
3082 601 : "Server is unavaliable",
3083 602 : "Peer nameserver is down",
3084 603 : "Database connection failed",
3085 604 : "Server is going down",
3086 605 : "Server unavailable",
3088 707 : "Could not create connection",
3089 710 : "Invalid CVR parameters",
3090 711 : "Write is blocking",
3091 712 : "Session is overloaded",
3092 713 : "Too many active users",
3093 714 : "Too many sessions",
3094 715 : "Not expected",
3095 717 : "Bad friend file",
3096 731 : "Not expected",
3098 800 : "Requests too rapid",
3100 910 : "Server too busy",
3101 911 : "Authentication failed",
3102 912 : "Server too busy",
3103 913 : "Not allowed when offline",
3104 914 : "Server too busy",
3105 915 : "Server too busy",
3106 916 : "Server too busy",
3107 917 : "Server too busy",
3108 918 : "Server too busy",
3109 919 : "Server too busy",
3110 920 : "Not accepting new users",
3111 921 : "Server too busy",
3112 922 : "Server too busy",
3113 923 : "No parent consent",
3114 924 : "Passport account not yet verified"
3118 # mapping of status codes to readable status format
3121 STATUS_ONLINE
: "Online",
3122 STATUS_OFFLINE
: "Offline",
3123 STATUS_HIDDEN
: "Appear Offline",
3124 STATUS_IDLE
: "Idle",
3125 STATUS_AWAY
: "Away",
3126 STATUS_BUSY
: "Busy",
3127 STATUS_BRB
: "Be Right Back",
3128 STATUS_PHONE
: "On the Phone",
3129 STATUS_LUNCH
: "Out to Lunch"
3133 # mapping of list ids to list codes
3136 FORWARD_LIST
: 'fl',
3139 REVERSE_LIST
: 'rl',
3144 # mapping of list codes to list ids
3146 for id,code
in listIDToCode
.items():
3147 listCodeToID
[code
] = id