From c95778ec00086d02220260b8ebc67dd23ce06182 Mon Sep 17 00:00:00 2001
From: jamesbunton <jamesbunton@55fbd22a-6204-0410-b2f0-b6c764c7e90a>
Date: Sat, 10 Dec 2005 11:13:30 +0000
Subject: [PATCH] Preliminary p2p file transfer passing tests! :)

git-svn-id: http://delx.cjb.net/svn/pymsnt/trunk@46 55fbd22a-6204-0410-b2f0-b6c764c7e90a

committer: jamesbunton <jamesbunton@55fbd22a-6204-0410-b2f0-b6c764c7e90a>
---
 src/tlib/msn/msn.py      | 240 ++++++++++++++++++++++++++++++---------
 src/tlib/msn/test_msn.py |  58 ++++++++--
 2 files changed, 240 insertions(+), 58 deletions(-)

diff --git a/src/tlib/msn/msn.py b/src/tlib/msn/msn.py
index 818c373..02adcdd 100644
--- a/src/tlib/msn/msn.py
+++ b/src/tlib/msn/msn.py
@@ -153,9 +153,15 @@ CR = "\r"
 LF = "\n"
 PINGSPEED = 50.0
 
-LINEDEBUG = True
-MESSAGEDEBUG = True
-MSNP2PDEBUG = True
+DEBUGALL = False
+LINEDEBUG = False
+MESSAGEDEBUG = False
+MSNP2PDEBUG = False
+
+if DEBUGALL:
+    LINEDEBUG = True
+    MESSAGEDEBUG = True
+    MSNP2PDEBUG = True
 
 def getVal(inp):
     return inp.split('=')[1]
@@ -2067,15 +2073,16 @@ class SwitchboardClient(MSNEventBase):
             if slpMessage.method == "INVITE":
                 if slpMessage.euf_guid == MSN_MSNFTP_GUID:
                     #FIXME!
-                    slpLink = SLPLink_Receive(remoteUser=slpMessage.fro, switchboard=self, consumer=FIXME, transferGuid=MSN_MSNFTP_GUID, sessionID=slpMessage.sessionID, sessionGuid=slpMessage.sessionGuid)
                     context = FileContext(slpMessage.context)
-                    fileReceive = msnft.MSNP2P_Receive(context.filename, context.filesize, slpMessage.fro)
+                    slpLink = SLPLink_FileReceive(remoteUser=slpMessage.fro, switchboard=self, filename=context.filename, filesize=context.filesize, sessionID=slpMessage.sessionID, sessionGuid=slpMessage.sessionGuid)
+                    self.slpLinks[slpMessage.sessionID] = slpLink
+                    self.gotFileReceive(slpLink)
                 elif slpMessage.euf_guid == MSN_AVATAR_GUID:
                     # Check that we have an avatar to send
                     if self.msnobj:
-                        slpLink = SLPLink_Send(remoteUser=slpMessage.fro, switchboard=self, length=self.msnobj.size, transferGuid=MSN_AVATAR_GUID, sessionID=slpMessage.sessionID, sessionGuid=slpMessage.sessionGuid)
+                        slpLink = SLPLink_AvatarSend(remoteUser=slpMessage.fro, switchboard=self, filesize=self.msnobj.size, sessionID=slpMessage.sessionID, sessionGuid=slpMessage.sessionGuid)
                         slpLink.write(self.msnobj.imageData)
-                        slpLink.finish()
+                        slpLink.close()
                     else:
                         # They shouldn't have sent a request if we have
                         # no avatar. So we'll just ignore them.
@@ -2199,6 +2206,15 @@ class SwitchboardClient(MSNEventBase):
         """
         pass
 
+    def gotFileReceive(self, fileReceive):
+        """
+        called when we receive a file send request from a contact
+
+        @param fileReceive: msnft.MSNFTReceive_Base instance
+        """
+        pass
+
+
     def gotSendRequest(self, fileReceive):
         """
         called when we receive a file send request from a contact
@@ -2282,11 +2298,34 @@ class SwitchboardClient(MSNEventBase):
         def bufferClosed(data):
             d.callback((data,))
         buffer = StringBuffer(bufferClosed)
-        slpLink = SLPLink_Receive(remoteUser=msnContact.userHandle, switchboard=self, consumer=buffer, transferGuid=MSN_AVATAR_GUID, context=msnContact.msnobj.text)
+        slpLink = SLPLink_AvatarReceive(remoteUser=msnContact.userHandle, switchboard=self, consumer=buffer, context=msnContact.msnobj.text)
         slpLink.avatarDataBuffer = buffer
         self.slpLinks[slpLink.sessionID] = slpLink
         return d
 
+    def sendFile(self, msnContact, filename, filesize):
+        """
+        used to send a file to a contact.
+
+        @param msnContact: the MSNContact object to send a file to.
+        @param filename: the name of the file to send.
+        @param filesize: the size of the file to send.
+        
+        @return: (fileSend, d) A FileSend object and a Deferred.
+                 The Deferred will pass one argument in a tuple,
+                 whether or not the transfer is accepted. If you
+                 receive a True, then you can call write() on the
+                 fileSend object to send your file. Call close()
+                 when the file is done.
+                 NOTE: You MUST write() exactly as much as you
+                 declare in filesize.
+        """
+        if not msnContact.userHandle: return
+        # FIXME, check msnContact.caps to see if we should use old-style
+        fileSend = SLPLink_FileSend(remoteUser=msnContact.userHandle, switchboard=self, filename=filename, filesize=filesize)
+        self.slpLinks[fileSend.sessionID] = fileSend
+        return fileSend, fileSend.acceptDeferred
+
     def sendTypingNotification(self):
         """
         Used to send a typing notification. Upon receiving this
@@ -2361,6 +2400,66 @@ class SwitchboardClient(MSNEventBase):
         self.sendMessage(m)
 
 
+class FileReceive:
+    def __init__(self, filename, filesize, userHandle):
+        self.consumer = None
+        self.finished = False
+        self.error = False
+        self.buffer = []
+        self.filename, self.filesize, self.userHandle = filename, filesize, userHandle
+
+    def reject(self):
+        raise NotImplementedError
+
+    def accept(self, consumer):
+        if self.consumer: raise "AlreadyAccepted"
+        self.consumer = consumer
+        for data in self.buffer:
+            self.consumer.write(data)
+        self.buffer = None
+        if self.finished:
+            self.consumer.close()
+        if self.error:
+            self.consumer.error()
+
+    def write(self, data):
+        if self.error or self.finished:
+            raise IOError, "Attempt to write in an invalid state"
+        if self.consumer:
+            self.consumer.write(data)
+        else:
+            self.buffer.append(data)
+
+    def close(self):
+        self.finished = True
+        if self.consumer:
+            self.consumer.close()
+
+class FileContext:
+    """ Represents the Context field for P2P file transfers """
+    def __init__(self, data=""):
+        if data:
+            self.parse(data)
+        else:
+            self.filename = ""
+            self.filesize = 0
+
+    def pack(self):
+        if MSNP2PDEBUG: print "FileContext packing:", self.filename, self.filesize
+        data = struct.pack("<LLQL", 574, 0x03, self.filesize, 0x01)
+        data += self.filename.encode("utf-16")
+        data = data.ljust(570, '\0')
+        data += struct.pack("<L", 0xFFFFFFFF)
+        return data
+
+    def parse(self, packet):
+        self.filesize = struct.unpack("<Q", packet[8:16])[0]
+        chunk = packet[20:540]
+        chunk = chunk[:chunk.find('\x00\x00')]
+        self.filename = unicode(chunk.decode("utf-16"))
+        if MSNP2PDEBUG: print "FileContext parsed:", self.filesize, self.filename
+
+
 class BinaryFields:
     """ Utility class for the binary header & footer in p2p messages """
     ACK = 0x02
@@ -2472,6 +2571,8 @@ class MSNSLPMessage:
                     self.sessionID = int(line[1].strip())
                 elif line[0] == "EUF-GUID":
                     self.euf_guid = line[1].strip()
+                elif line[0] == "Context":
+                    self.context = base64.decodestring(line[1])
 
     def __str__(self):
         s = []
@@ -2520,7 +2621,7 @@ class StringBuffer(StringIO.StringIO):
         self.notifyFunc = notifyFunc
         StringIO.StringIO.__init__(self)
 
-    def finish(self):
+    def close(self):
         if self.notifyFunc:
             self.notifyFunc(self.getvalue())
             self.notifyFunc = None
@@ -2595,27 +2696,20 @@ class SLPLink:
         message.ack = MSNMessage.MESSAGE_ACK_FAT
         self.switchboard.sendMessage(message)
 
+    def handleSLPMessage(self):
+        raise NotImplementedError
+
 
 
     
 
 class SLPLink_Send(SLPLink):
-    def __init__(self, remoteUser, switchboard, length, transferGuid, sessionID=None, sessionGuid=None):
+    def __init__(self, remoteUser, switchboard, filesize, sessionID=None, sessionGuid=None):
         SLPLink.__init__(self, remoteUser, switchboard, sessionID, sessionGuid)
         self.handlePacket = None
-        self.transferGuid = transferGuid
         self.offset = 0
-        self.length = length
+        self.filesize = filesize
         self.data = ""
-        # Send dataprep
-        if transferGuid == MSN_AVATAR_GUID:
-            self.sendMSNSLPResponse("200 OK")
-            self.send_dataprep()
-        elif transferGuid == MSN_MSNFTP_GUID:
-            # FIXME Send invite & wait for 200OK before sending dataprep
-            pass
-        else:
-            raise "NotSupportedGuid"
     
     def send_dataprep(self):
         binaryFields = BinaryFields()
@@ -2647,7 +2741,7 @@ class SLPLink_Send(SLPLink):
         binaryFields[0] = self.sessionID
         binaryFields[1] = self.seqID.get()
         binaryFields[2] = self.offset
-        binaryFields[3] = self.length
+        binaryFields[3] = self.filesize
         binaryFields[4] = len(chunk)
         binaryFields[5] = BinaryFields.DATA
         binaryFields[6] = random.randint(1000, sys.maxint)
@@ -2655,45 +2749,58 @@ class SLPLink_Send(SLPLink):
         self.offset += len(chunk)
         self.sendP2PMessage(binaryFields, chunk)
     
-    def finish(self):
+    def close(self):
         if self.data:
             self._writeChunk(self.data)
-        if self.transferGuid == MSN_AVATAR_GUID:
-            pass # Keep the link open to wait for a BYE
-        elif self.transferGuid == MSN_MSNFTP_GUID:
-            self.sendMSNSLPCommand("BYE", MSN_AVATAR_GUID, "\0") # FIXME, is this right?
         self.killLink()
     
     def error(self):
         pass
         # FIXME, should send 601 or something
 
+class SLPLink_FileSend(SLPLink_Send):
+    def __init__(self, remoteUser, switchboard, filename, filesize):
+        SLPLink_Send.__init__(self, remoteUser=remoteUser, switchboard=switchboard, filesize=filesize)
+        # Send invite & wait for 200OK before sending dataprep
+        context = FileContext()
+        context.filename = filename
+        context.filesize = filesize
+        self.sendMSNSLPCommand("INVITE", MSN_MSNFTP_GUID, context.pack())
+        self.acceptDeferred = Deferred()
+
+    def handleSLPMessage(self, slpMessage):
+        if slpMessage.status == "200":
+            self.send_dataprep()
+            self.acceptDeferred.callback((True,))
+        else:
+            if slpMessage.status == "603":
+                self.acceptDeferred.callback((False,))
+            # SLPLink is over due to decline, error or BYE
+            self.killLink()
+
+    def close(self):
+        SLPLink_Send.close(self)
+        # FIXME, check whether we should wait for a BYE or send one
+        self.sendMSNSLPCommand("BYE", MSN_AVATAR_GUID, "\0")
+
+
+class SLPLink_AvatarSend(SLPLink_Send):
+    def __init__(self, remoteUser, switchboard, filesize, sessionID=None, sessionGuid=None):
+        SLPLink_Send.__init__(self, remoteUser=remoteUser, switchboard=switchboard, filesize=filesize, sessionID=sessionID, sessionGuid=sessionGuid)
+        self.sendMSNSLPResponse("200 OK")
+        self.send_dataprep()
+
+    def close(self):
+        SLPLink_Send.close(self)
+        # Keep the link open to wait for a BYE
 
 class SLPLink_Receive(SLPLink):
-    def __init__(self, remoteUser, switchboard, consumer, transferGuid, context=None, sessionID=None, sessionGuid=None):
+    def __init__(self, remoteUser, switchboard, consumer, context=None, sessionID=None, sessionGuid=None):
         SLPLink.__init__(self, remoteUser, switchboard, sessionID, sessionGuid)
         self.handlePacket = None
-        self.transferGuid = transferGuid
         self.consumer = consumer
         self.pos = 0
 
-        if transferGuid == MSN_AVATAR_GUID:
-            self.sendMSNSLPCommand("INVITE", MSN_AVATAR_GUID, context)
-        elif transferGuid == MSN_MSNFTP_GUID:
-            pass # FIXME
-        else:
-            raise "NotSupportedGuid"
-
-    def handleSLPMessage(self, slpMessage):
-        if self.transferGuid == MSN_AVATAR_GUID:
-            if slpMessage.status == "200":
-                self.handlePacket = self.wait_dataprep
-            else:
-                # SLPLink is over due to error or BYE
-                self.killLink()
-        elif self.transferGuid == MSN_MSNFTP_GUID:
-            pass #FIXME
-    
     def wait_dataprep(self, packet):
         binaryFields = BinaryFields()
         binaryFields.unpackFields(packet)
@@ -2746,17 +2853,48 @@ class SLPLink_Receive(SLPLink):
 
         if self.pos == total:
             self.sendP2PACK(binaryFields)
-            self.consumer.finish()
+            self.consumer.close()
             self.handlePacket = None
-            if self.transferGuid == MSN_AVATAR_GUID:
-                self.sendMSNSLPCommand("BYE", MSN_AVATAR_GUID, "\0")
-            elif self.transferGuid == MSN_MSNFTP_GUID:
-                pass # Link is kept around waiting for a BYE
+            self.doFinished()
 
+    def doFinished(self):
+        raise NotImplementedError
 
 
+class SLPLink_FileReceive(SLPLink_Receive, FileReceive):
+    def __init__(self, remoteUser, switchboard, filename, filesize, sessionID, sessionGuid):
+        SLPLink_Receive.__init__(self, remoteUser=remoteUser, switchboard=switchboard, consumer=self, sessionID=sessionID, sessionGuid=sessionGuid)
+        FileReceive.__init__(self, filename, filesize, remoteUser)
+
+    def reject(self):
+        pass
+
+    def accept(self, consumer):
+        FileReceive.accept(self, consumer)
+        self.sendMSNSLPResponse("200 OK")
+        self.handlePacket = self.wait_dataprep
 
+    def handleSLPMessage(self, slpMessage):
+        # FIXME, do some error handling if it was an error
+        self.killLink() # It's either a BYE or an error
+
+    def doFinished(self):
+        pass # Link is kept around waiting for a BYE
+
+class SLPLink_AvatarReceive(SLPLink_Receive):
+    def __init__(self, remoteUser, switchboard, consumer, context):
+        SLPLink_Receive.__init__(self, remoteUser=remoteUser, switchboard=switchboard, consumer=consumer, context=context)
+        self.sendMSNSLPCommand("INVITE", MSN_AVATAR_GUID, context)
+
+    def handleSLPMessage(self, slpMessage):
+        if slpMessage.status == "200":
+            self.handlePacket = self.wait_dataprep
+        else:
+            # SLPLink is over due to error or BYE
+            self.killLink()
 
+    def doFinished(self):
+        self.sendMSNSLPCommand("BYE", MSN_AVATAR_GUID, "\0")
 
 # mapping of error codes to error messages
 errorCodes = {
diff --git a/src/tlib/msn/test_msn.py b/src/tlib/msn/test_msn.py
index 6009ed9..5e55e1a 100644
--- a/src/tlib/msn/test_msn.py
+++ b/src/tlib/msn/test_msn.py
@@ -15,7 +15,7 @@ from twisted.python import failure
 from twisted.trial import unittest
 
 # System imports
-import StringIO, sys, urllib
+import StringIO, sys, urllib, random, struct
 
 import msn
 import msnft
@@ -965,6 +965,9 @@ class DummySwitchboardP2PClient(msn.SwitchboardClient):
         if message.message == "Test Message" and message.userHandle == "foo1@bar.com":
             self.status = "GOTMESSAGE"
 
+    def gotFileReceive(self, fileReceive):
+        self.fileReceive = fileReceive
+
 class SwitchboardP2PTests(unittest.TestCase):
     def setUp(self):
         self.server  = DummySwitchboardP2PServer()
@@ -982,17 +985,27 @@ class SwitchboardP2PTests(unittest.TestCase):
         self.loop1.disconnect()
         self.loop2.disconnect()
 
+    def _loop(self, steps=1):
+        for i in xrange(steps):
+            self.loop1.doSteps(1)
+            self.loop2.doSteps(1)
+
     def testMessage(self):
         self.client1.sendMessage(msn.MSNMessage(message='Test Message'))
-        self.loop1.doSteps(10)
-        self.loop2.doSteps(10)
+        self._loop()
         self.failUnless((self.client2.status == "GOTMESSAGE"), "Fake switchboard server not working.")
+
+    def _generateData(self):
+        data = ''
+        for i in xrange(3000):
+            data += struct.pack("<L", random.randint(0, sys.maxint))
+        return data
     
     def testAvatars(self):
         self.gotAvatar = False
 
         # Set up the avatar for client1
-        imageData = 'avatar image data' * 1000
+        imageData = self._generateData()
         self.client1.msnobj = msn.MSNObject()
         self.client1.msnobj.setData('foo1@bar.com', imageData)
         self.client1.msnobj.makeText()
@@ -1005,13 +1018,44 @@ class SwitchboardP2PTests(unittest.TestCase):
         d.addCallback(avatarCallback)
 
         # Let them do their thing
-        for i in xrange(10):
-            self.loop1.doSteps(1)
-            self.loop2.doSteps(1)
+        self._loop(10)
 
         # Check that client2 got the avatar
         self.failUnless((self.gotAvatar), "Failed to transfer avatar")
 
+    def testFiles(self):
+        fileData = self._generateData()
+        self.gotFile = False
+
+        # Send the file (client2->client1)
+        msnContact = msn.MSNContact(userHandle='foo1@bar.com', caps=msn.MSNContact.MSNC1)
+        fileSend, d = self.client2.sendFile(msnContact, "myfile.txt", len(fileData))
+        def accepted((yes,)):
+            if yes:
+                fileSend.write(fileData)
+                fileSend.close()
+            else:
+                raise "TransferDeclined"
+        def failed():
+            raise "TransferError"
+        d.addCallback(accepted)
+        d.addErrback(failed)
+
+        # Let the request get pushed to client1
+        self._loop(10)
+
+        # Receive the file
+        def finished(data):
+            self.gotFile = (data == fileData)
+        fileBuffer = msn.StringBuffer(finished)
+        fileReceive = self.client1.fileReceive
+        fileReceive.accept(fileBuffer)
+
+        # Lets transfer!!
+        self._loop(100)
+
+        self.failUnless((self.gotFile), "Failed to transfer file")
+
 
 ################
 # MSNFTP tests #
-- 
2.39.2