home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / yahoo / peerfiletransfer.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  8.6 KB  |  297 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from common.filetransfer import IncomingFileTransfer
  5. from util.primitives import Storage
  6. from httplib import HTTPConnection
  7. from urllib import quote
  8. from util.net import FileChunker
  9. from path import path
  10. from urlparse import urlparse
  11. from util.threads.threadpool2 import threaded
  12. from common.filetransfer import OutgoingFileTransfer
  13. from random import choice
  14. from traceback import print_exc
  15. from yfiletransfer import OutgoingYHTTPXfer
  16. import dns
  17. import logging
  18. log = logging.getLogger('yahoo.peerft')
  19. info = log.info
  20. error = log.error
  21.  
  22. class YahooPeerFileTransfer(IncomingFileTransfer):
  23.     
  24.     def __init__(self, yahoo, buddy, **kws):
  25.         IncomingFileTransfer.__init__(self)
  26.         self.yahoo = yahoo
  27.         self.buddy = buddy
  28.         self.name = kws['filename']
  29.         self.packet = Storage(**kws)
  30.         self.numfiles = 1
  31.         self.size = int(kws['filesize'])
  32.         self.on_get_buddy(self.buddy)
  33.  
  34.     
  35.     def protocol(self):
  36.         return self.yahoo
  37.  
  38.     protocol = property(protocol)
  39.     
  40.     def decline(self):
  41.         self.yahoo.send('peerrequest', 'available', [
  42.             'frombuddy',
  43.             self.packet.to,
  44.             'to',
  45.             self.packet.buddyname,
  46.             'p2pcookie',
  47.             self.packet.p2pcookie,
  48.             'acceptxfer',
  49.             '4'])
  50.         self.state = self.states.CANCELLED_BY_YOU
  51.         IncomingFileTransfer.decline(self)
  52.  
  53.     
  54.     def accept(self, openfile):
  55.         self.packet.acceptxfer = '3'
  56.         self.openfile = openfile
  57.         self.yahoo.send('peerrequest', 'available', [
  58.             'frombuddy',
  59.             self.packet.to,
  60.             'to',
  61.             self.packet.buddyname,
  62.             'p2pcookie',
  63.             self.packet['p2pcookie'],
  64.             'acceptxfer',
  65.             '3'])
  66.         self.state = self.states.CONNECTING
  67.  
  68.     
  69.     def connect(self, buddy, filename, peer_path, p2pcookie, peerip, transfertype):
  70.         myname = self.yahoo.self_buddy.name
  71.         if transfertype == '1':
  72.             u = urlparse(peerip)
  73.             url = u.path + '?' + u.query
  74.             peerip = u.netloc
  75.         else:
  76.             url = '/relay?token=%s&sender=%s&recver=%s' % (quote(peer_path), myname, buddy)
  77.         if peerip:
  78.             info('Got a relay IP; connecting...')
  79.             info('HTTP HEAD: %s', peerip)
  80.             relayconn = HTTPConnection(peerip)
  81.             headers = {
  82.                 'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5)',
  83.                 'Accept': '*/*',
  84.                 'Cache-Control': 'no-cache',
  85.                 'Cookie': self.yahoo.cookie_str }
  86.             relayconn.request('HEAD', url, headers = headers)
  87.             response = relayconn.getresponse()
  88.             status = response.status
  89.             if status != 200:
  90.                 return log.error('ERROR: HEAD request returned a status of %d', status)
  91.             print 'resp1 in'
  92.             print response.read()
  93.             print 'resp1 out'
  94.             relayconn.request('GET', url, headers = headers)
  95.             if transfertype != '1':
  96.                 self.yahoo.send('peerinit', 'available', frombuddy = myname, to = buddy, p2pcookie = p2pcookie, filename = filename, transfertype = '3', peer_path = peer_path)
  97.             
  98.             response = relayconn.getresponse()
  99.             status = response.status
  100.             if status != 200:
  101.                 return log.error('ERROR: GET req returned %d status', status)
  102.             
  103.             response.info = lambda : dict(response.getheaders())
  104.             headers = response.info()
  105.             
  106.             bytecounter = lambda : 0
  107.             if self.state != self.states.CANCELLED_BY_YOU:
  108.                 self.state = self.states.TRANSFERRING
  109.                 self.filepath = path(self.openfile.name)
  110.                 gen = FileChunker.tofile_gen(response, self.openfile, self.progress, bytecounter = bytecounter)
  111.                 self.chunker = gen.next()
  112.                 
  113.                 try:
  114.                     gen.next()
  115.                 except StopIteration:
  116.                     (status != 200,)
  117.                     (status != 200,)
  118.                 except:
  119.                     (status != 200,)
  120.  
  121.                 if self.bytes_read != self.size:
  122.                     self.state = self.states.CONN_FAIL_XFER
  123.                 
  124.             
  125.             if self.state != self.states.CANCELLED_BY_YOU:
  126.                 self._ondone()
  127.             
  128.         else:
  129.             log.warning('No peer IP, buddy will connect to me. NOT IMPLEMENTED')
  130.  
  131.     connect = threaded(connect)
  132.     
  133.     def progress(self, bytes_read):
  134.         self._setcompleted(bytes_read)
  135.         self.bytes_read = bytes_read
  136.  
  137.     
  138.     def cancel(self, me = True, state = None):
  139.         if me:
  140.             self.yahoo.send('peerinit', 'cancel', [
  141.                 'frombuddy',
  142.                 self.packet.to,
  143.                 'to',
  144.                 self.packet.buddyname,
  145.                 'p2pcookie',
  146.                 self.packet.p2pcookie,
  147.                 'error',
  148.                 '-1'])
  149.             if state is None:
  150.                 state = self.states.CANCELLED_BY_YOU
  151.             
  152.             self.state = state
  153.         else:
  154.             self.state = self.states.CANCELLED_BY_BUDDY
  155.         
  156.         try:
  157.             self.chunker.cancelled = True
  158.         except Exception:
  159.             print_exc()
  160.  
  161.         self._ondone()
  162.  
  163.     
  164.     def _ondone(self):
  165.         
  166.         try:
  167.             self.yahoo.file_transfers.pop((self.packet.buddyname, self.packet.p2pcookie))
  168.         except Exception:
  169.             log.warning('_ondone pop failed')
  170.  
  171.         
  172.         try:
  173.             IncomingFileTransfer._ondone(self)
  174.         except Exception:
  175.             log.warning('_ondone call failed')
  176.  
  177.  
  178.  
  179.  
  180. class YahooOutgoingPeerFileXfer(OutgoingYHTTPXfer):
  181.     
  182.     def __init__(self, protocol, buddy = None, fileinfo = None):
  183.         OutgoingYHTTPXfer.__init__(self, protocol, buddy = buddy, fileinfo = fileinfo, initiate = False)
  184.         self.yahoo = protocol
  185.  
  186.     
  187.     def send_offer(self):
  188.         log.critical('send_offer')
  189.         import string
  190.         letters = string.ascii_letters + string.digits
  191.         cookie = []
  192.         for _i in xrange(22):
  193.             cookie.append(choice(letters))
  194.         
  195.         self.cookie = cookie = ''.join(cookie) + '$$'
  196.         self.yahoo.file_transfers[(self.buddy.name, self.cookie)] = self
  197.         self.yahoo.send('peerrequest', 'available', [
  198.             'frombuddy',
  199.             self.yahoo.self_buddy.name,
  200.             'to',
  201.             self.buddy.name,
  202.             'p2pcookie',
  203.             self.cookie,
  204.             'acceptxfer',
  205.             '1',
  206.             '266',
  207.             '1',
  208.             'begin_mode',
  209.             '268',
  210.             'begin_entry',
  211.             '268',
  212.             'filename',
  213.             self.name,
  214.             'filesize',
  215.             str(self.size),
  216.             'end_entry',
  217.             '268',
  218.             'end_mode',
  219.             '268'])
  220.         self.state = self.states.WAITING_FOR_BUDDY
  221.  
  222.     
  223.     def do_setup(self, buddy, p2pcookie, filename = None, peer_path = None, **k):
  224.         log.critical('do_setup')
  225.         self.state = self.states.CONNECTING
  226.         
  227.         def get_ip():
  228.             for ip in dns.resolver.query('relay.msg.yahoo.com', 'A'):
  229.                 return str(ip)
  230.             
  231.             raise Exception, 'no ip for relay transfer'
  232.  
  233.         get_ip = threaded(get_ip)
  234.         
  235.         def send_later(ip):
  236.             self.host = ip
  237.             self.conn_host = ip
  238.             self.yahoo.send('peersetup', 'available', [
  239.                 'frombuddy',
  240.                 self.yahoo.self_buddy.name,
  241.                 'to',
  242.                 self.buddy.name,
  243.                 'p2pcookie',
  244.                 self.cookie,
  245.                 'filename',
  246.                 self.name,
  247.                 'transfertype',
  248.                 '3',
  249.                 'peerip',
  250.                 ip])
  251.  
  252.         get_ip(success = send_later)
  253.  
  254.     
  255.     def go(self, buddy, p2pcookie, filename, transfertype, peer_path, **k):
  256.         log.critical('go')
  257.         peer_path = quote(peer_path)
  258.         self.http_path = '/relay?token=' + peer_path + '&sender=' + self.yahoo.self_buddy.name + '&recver=' + buddy
  259.         self.state = self.states.TRANSFERRING
  260.         
  261.         try:
  262.             filesize = self.filepath.size
  263.             fileobj = file(self.filepath, 'rb')
  264.         except Exception:
  265.             e = None
  266.             print_exc()
  267.             self.state = self.states.CONN_FAIL
  268.             self.on_error()
  269.  
  270.         self._post_file('', self.yahoo.cookie_str, fileobj = fileobj, filesize = filesize)
  271.  
  272.     
  273.     def cancel(self, me = True):
  274.         self.cancelled = True
  275.         if me:
  276.             self.yahoo.send('peersetup', 'cancel', [
  277.                 'frombuddy',
  278.                 self.yahoo.self_buddy.name,
  279.                 'to',
  280.                 self.buddy.name,
  281.                 'p2pcookie',
  282.                 self.cookie,
  283.                 '66',
  284.                 '-1'])
  285.             self.state = self.states.CANCELLED_BY_YOU
  286.         else:
  287.             self.state = self.states.CANCELLED_BY_BUDDY
  288.         
  289.         try:
  290.             self.conn.close()
  291.             del self.conn
  292.         except:
  293.             pass
  294.  
  295.  
  296.  
  297.