Maximum CD 2011 October/maximum-cd-2011-10.iso/DiscContents/digsby_setup.exe/lib/oscar/rendezvous/filetransfer.pyo

Python Compiled Bytecode | 2011-06-22 | 21.0 KB | 536 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

from __future__ import with_statement
__metaclass__ = type
from oscar.rendezvous.peer import OscarPeer
from oscar.rendezvous.rendezvous import oscarcookie, map_intarg, rendezvous_tlvs
import oscar.capabilities as capabilities
from util import Storage, strlist, NoneFileChunker, to_hex
from util.packable import Packable
import util
import oscar.snac as oscar
import oscar.OscarUtil as oscar
import common
import hooks
from path import path
import os.path as os
import traceback
import struct
from logging import getLogger
log = getLogger('oscar.rdv.ft')
info = log.info

def prettyoft(oft):
    return '\n'.join((lambda .0: for line in .0:
'%20s: %r' % line)(list(iter(oft))))

rz = rendezvous_tlvs
tlv = oscar.OscarUtil.tlv
tlv_list = oscar.OscarUtil.tlv_list

def send(oscar, screenname, filestorage):
    cookie = oscarcookie()
    oscar.rdv_sessions[cookie] = transfer = OutgoingOscarFileTransfer(oscar, screenname, cookie, filestorage)
    transfer.request()
    return transfer


class OFTHeader(Packable):
    fmt = strlist('\n        protocol_version 4s  # Always \'OFT2\'\n        length           H   # includes all data, including version and length\n        type             H   # one of "types" below\n    ')
    invars = [
        (lambda self: self.protocol_version == 'OFT2'),
        (lambda self: self.type in self.types.values())]
    types = Storage(prompt = 257, ack = 514, done = 516, receiver_resume = 517, sender_resume = 262, rcv_resume_ack = 519)


class OFTBody(Packable):
    fmt = strlist("\n    cookie              Q\n    encryption          H\n    compression         H\n    num_files           H\n    files_left          H\n    num_parts           H\n    parts_left          H\n    total_size          I\n    file_size           I\n\n    modification_time   I   # since unix epoch\n    checksum            I   # see OscarFileTransferChecksum\n    recv_fork_checksum  I\n    fork_size           I\n    creation_time       I\n    fork_checksum       I\n    bytes_received      I\n    recv_checksum       I\n    id_string           32s # 32 byte right padded string: usually 'CoolFileXfer'\n\n    flags               B   # Flags: 0x20 - Negotiation (not complete), 0x01 - Done\n    list_name_offset    B   # always 0x1c\n    list_size_offset    B   # always 0x11\n\n    dummy_block         69s # Dummy Block - large null block for future expansion of OFT\n\n    mac_file_info       16s # Mac File Info\n\n    charset             H   # charset\n    subset              H   # subset: 0 for ASCII, 2 for UTF-16BE, 3 for ISO-8859-1\n    ")
    default_checksum = 0xFFFF0000L

    def padfilename(filename):
        if len(filename) < 64:
            filename += '\x00' * (64 - len(filename))

        return filename

    padfilename = staticmethod(padfilename)

OFTId = 'Cool FileXfer'
OFTId = OFTId + '\x00' * (32 - len(OFTId))

class OscarFileTransfer(OscarPeer):

    def __init__(self, protocol, screenname, cookie):
        OscarPeer.__init__(self, protocol, screenname, cookie, capabilities.by_name['file_xfer'])
        common.FileTransfer.__init__(self)
        self.cancelled = False
        self.resuming = False
        self.on_get_buddy(self.buddy)


    def ch2cancel(self, data):
        log.info('%r cancelled by buddy', self)
        self.cancelled = True
        self.cancel_by_buddy()
        if data:
            log.info('data in a ch2 cancel: %s', to_hex(data))



    def cancel_by_buddy(self):
        log.info('cancel_by_buddy')
        if self.state != self.states.CANCELLED_BY_YOU:
            self.state = self.states.CANCELLED_BY_BUDDY


        try:
            self.fileobj.close()
        except Exception:
            traceback.print_exc()



    def on_close(self):
        log.info('%r on_close', self)

        try:
            self.fileobj.close()
        except AttributeError:
            pass

        if self.state == self.states.TRANSFERRING:
            self.state = self.states.CONN_FAIL_XFER
            self.on_error()



    def close(self):
        log.info('close')

        try:
            self.socket.close()
            del self.socket
        except Exception:
            pass

        self.done = True

        try:
            self.fileobj.close()
        except AttributeError:
            pass



    def cancel(self, msg = '', state = None):
        if hasattr(self, 'socket') and self.socket:

            try:
                self.socket.cancel_timeout()
            except Exception:
                traceback.print_exc()
            except:
                None<EXCEPTION MATCH>Exception


        None<EXCEPTION MATCH>Exception

        try:
            self.filechunker.cancelled = True
        except Exception:
            traceback.print_exc()
            info('$$$ sending cancel')
            self.send_rdv('cancel')

        self.close()
        self.setnotifyif('cancelled', True)
        info('%r cancelled. %s', self, msg)
        if state is None:
            state = self.states.CANCELLED_BY_YOU

        self.state = state


    def ch2accept(self, data):
        if data:
            log.error('got data in a channel 2 accept: data = %r', data)
            self.cancel()
        else:
            log.info('ch2accept data = %r', data)


    def decline_transfer(self, reason = None):
        log.info('decline_transfer: reason = %r', reason)
        self.cancel()


    def send_oft(self, type, setvalues = True):
        oft = self.oft
        if not oft:
            return None
        info('sending oft %s for %s', type, self.filename)
        info(prettyoft(oft) + '\n  filename: %s', self.filename)
        self.socket.push(oftpacket(type, oft, self.filename))



class OutgoingOscarFileTransfer(OscarFileTransfer, common.OutgoingFileTransfer):

    def __init__(self, o, screenname, cookie, fileinfo):
        OscarFileTransfer.__init__(self, o, screenname, cookie)
        [ setattr(self, a, fileinfo[a]) for a in 'name files size numfiles'.split() ]
        self.filepath = path(fileinfo.path)
        self.fileobj = None
        self.oft = self.next_file()
        self.accepted = False
        self.connected = False
        self.completed = 0
        self.state = self.states.WAITING_FOR_BUDDY


    def next_file(self):
        if self.files:
            self.file = self.files.pop(0)
            if hasattr(self, 'rootpath'):
                p = self.rootpath.relpathto(self.file)
                self.filename = p.normpath().replace('\\', '/').replace('/', chr(1))
            else:
                self.filename = self.file.name
            return self.oft_for_file(self.file)
        self.file = None
        return False


    def __repr__(self):
        if not getattr(self.file, 'name', None):
            pass
        return '<OutgoingOscarFileTransfer to %s (%r)>' % (self.screenname, '')


    def request(self, message = '<html>'):
        xdata = xdata_block(self.name, self.size, self.numfiles)
        self.establish_out_dc(message = message, extratlvs = [
            (rz.extended_data, xdata),
            (rz.filename_encoding, 'utf-8')])


    def on_odc_connection(self):
        info('%r connected!', self)
        self.connected = True
        self.maybe_start()


    def received_oft_header(self, data):
        (header, data) = OFTHeader.unpack(data)
        log.debug('received OFT header: oft=%(protocol_version)s length=0x%(length)x type=0x%(type)x', dict(header))
        bytes_left = header.length - OFTHeader._struct.size
        if header.type in (OFTHeader.types.ack, OFTHeader.types.rcv_resume_ack):
            self.open_file()
        elif header.type == OFTHeader.types.done:

            try:
                self.fileobj.close()
            except AttributeError:
                pass

            self.fileobj = None
            self.oft = self.next_file()
            if not self.oft:
                if self.completed:
                    self.state = self.states.FINISHED
                    self._ondone()
                else:
                    self.cancel_by_buddy()
                self.close()

            return None
        if header.type == OFTHeader.types.receiver_resume:
            log.info('Going to resume file %s' % self.file)
            self.resuming = True
        else:
            log.warning('Error! OFT type %r', header.type)
        self.socket.receive_next(bytes_left, self.received_oft_body)


    def open_file(self):

        try:
            self.fileobj = self.file.open('rb')
            return True
        except IOError:
            self.cancel('Could not open file %s' % self.file)
            return False



    def received_oft_body(self, data):
        (oft, data) = OFTBody.unpack(data)
        (filename, data) = read_cstring(data)
        info(prettyoft(oft) + '\n  filename: %s', filename)
        self.oft = oft
        self.socket.receive_next(OFTHeader, self.received_oft_header)
        if self.fileobj:
            if self.resuming:
                self.fileobj.seek(oft.bytes_received)
                self._setcompleted(self.fileobj.tell())

            self.filechunker = NoneFileChunker(self.fileobj, close_when_done = True, progress_cb = self._setcompleted)
            log.info('Pushing FileChunker onto socket')
            self.socket.push_with_producer(self.filechunker)
        elif self.oft:
            if self.resuming:
                self.send_oft('sender_resume', False)
            else:
                self.send_oft('prompt')
        else:
            info('DONE!')
            self.state = self.states.FINISHED
            self.close()


    def ch2accept(self, data):
        info('received CH2 accept')
        self.accepted = True
        self.maybe_start()


    def maybe_start(self):
        if not (self.accepted) or not (self.connected):
            if not self.accepted:
                info('no RDV accept yet')

            if not self.connected:
                info('no connection yet')

            return None
        self.state = self.states.TRANSFERRING
        if not getattr(self, 'sent_first', False):
            info('sending first oft prompt')
            self.sent_first = True
            self.send_oft('prompt')

        self.socket.receive_next(OFTHeader, self.received_oft_header)


    def oft_for_file(self, file):
        return OFTBody(cookie = self.cookie, num_files = self.numfiles, files_left = 1 + len(self.files), num_parts = 1, parts_left = 1, total_size = self.size, file_size = file.size, modification_time = int(file.mtime), creation_time = int(file.ctime), checksum = OFTBody.default_checksum, recv_fork_checksum = OFTBody.default_checksum, fork_checksum = OFTBody.default_checksum, recv_checksum = OFTBody.default_checksum, id_string = OFTId, dummy_block = '\x00' * 69, mac_file_info = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00', charset = 0, subset = 0)



class IncomingOscarFileTransfer(OscarFileTransfer, common.IncomingFileTransfer):
    direction = 'incoming'

    def __init__(self, o, screenname, cookie):
        OscarFileTransfer.__init__(self, o, screenname, cookie)
        self.completed = 0


    def handle_request(self, rendtlvs):
        (info, data) = unpack_extended_data(rendtlvs.extended_data)
        self.__dict__.update(info)
        self._onrequest()


    def accept(self, file_obj):
        if self.cancelled:
            e = OscarFileTransferError('The sender has already cancelled this file request.')
            self.protocol.hub.on_error(e)
        elif isinstance(file_obj, file) or self.numfiles == 1:
            self.filepath = path(file_obj.name)
            self.rootpath = self.filepath.parent
            file_obj.close()
        else:
            self.rootpath = os.path.join(file_obj, self.name)
            if not os.path.exists(self.rootpath):
                os.makedirs(self.rootpath)

            self.filepath = path(self.rootpath)
        info('self.rootpath = %r', self.rootpath)
        None(info, 'accepting incoming file transfer, saving %s to %s' if self.numfiles == 1 else 'files', self.rootpath)
        self.state = self.states.CONNECTING
        self.establish_dc()


    def decline(self):
        self.state = self.states.CANCELLED_BY_YOU
        self.send_rdv('cancel')
        common.IncomingFileTransfer.decline(self)


    def on_odc_connection(self):
        self.state = self.states.TRANSFERRING
        self.socket.receive_next(OFTHeader, self.received_oft_header)


    def received_oft_header(self, data):
        (header, data) = OFTHeader.unpack(data)
        log.debug('received OFT header: %r', dict(header))
        if header.type == OFTHeader.types.prompt:
            bytes_left = header.length - OFTHeader._struct.size
            log.debug('receiving %d more OFT body bytes', bytes_left)
            self.socket.receive_next(bytes_left, self.received_oft_body)
        else:
            self.fail('Error! OFT type ' + str(header.type))


    def received_oft_body(self, data):
        (oft, data) = OFTBody.unpack(data)
        self.oft = oft
        info('incoming oft body...\n' + prettyoft(oft))
        nullindex = data.find('\x00')
        if nullindex == -1 and len(data) >= 64:
            self.filename = filename = data
        elif nullindex == -1:
            raise AssertionError("couldn't find a null byte in the padded filename")
        else:
            self.filename = filename = data[:nullindex]
        self.fileobj = openpath(self.rootpath, self.filepath.name)
        info('incoming file: %s (%d bytes), %d left', filename, oft.file_size, oft.files_left)
        self.send_oft('ack')
        self.socket.push_collector(self.collect_file_bytes)
        if oft.file_size > 0:
            self.socket.receive_next(oft.file_size, self.received_file)
        else:
            self.received_file()


    def collect_file_bytes(self, data):

        try:
            self.fileobj.write(data)
        except IOError:
            traceback.print_exc()
            return None
        else:
            completed = self.fileobj.tell()
            self.oft.bytes_received = completed
            self._setcompleted(completed)
        finally:
            self.data = ''



    def received_file(self, *data):
        self.socket.pop_collector()
        info('received file %s', self.fileobj.name)
        self.fileobj.close()
        self.send_oft('done')
        if self.oft.files_left == 1:
            info('done!')
            self._ondone()
            self.socket.close()
        else:
            self.socket.receive_next(OFTHeader, self.received_oft_header)


    def fail(self, msg):
        log.error(msg)
        self.close()


    def __repr__(self):
        return '<IncomingOFT from %s>' % self.screenname



def oftpacket(type, body, filename):
    if isinstance(filename, unicode):
        filename = filename.encode('utf8')
    else:
        filename = str(filename)
    padded = OFTBody.padfilename(filename)
    return ''.join([
        OFTHeader('OFT2', length = 192 + len(padded), type = map_intarg(type, OFTHeader.types)).pack(),
        body.pack(),
        padded])


def oft_filename(fn):
    fn += chr(0)
    if len(fn) < 64:
        fn += (64 - len(fn)) * chr(0)

    return fn


def read_cstring(data):
    i = data.find(chr(0))
    if i == -1:
        raise ValueError('not a null terminated string')
    i == -1
    return (data[:i], data[i + 1:])


def unpack_extended_data(data):
    (multiple, filecount, totalbytes) = struct.unpack('!HHI', data[:8])
    data = data[8:]
    (filename, data) = read_cstring(data)
    return (util.Storage(numfiles = filecount, multiple = multiple == 2, size = totalbytes, name = filename), data)


def xdata_block(filename, filesize, filecount = 1):
    return None(struct.pack, '!HHI' if filecount == 1 else 2, filecount, filesize) + filename.encode('utf-8') + '\x00'


def openpath(rootpath, filename):
    PATHSEP = chr(1)
    needdirs = filename.find(PATHSEP) != -1
    path = filename.split(PATHSEP)
    filename = path.pop(-1)
    path = [
        rootpath] + path
    if needdirs:
        pathstr = os.path.join(*path)
        if not os.path.exists(pathstr):
            info('calling makedirs(%s)', pathstr)
            os.makedirs(pathstr)


    filepath = path + [
        filename]
    return open(os.path.join(*filepath), 'wb')


class OscarFileTransferError(Exception):
    pass


class OFTChecksum(object):
    starting_value = 0xFFFF0000L

    def __init__(self, data = None):
        self.checksum = self.starting_value
        if data is not None:
            self.update(data)



    def update(self, data, offset = 0):
        check = self.checksum >> 16 & 0xFFFFL
        for i in xrange(len(data)):
            oldcheck = check
            byteval = ord(data[offset + i]) & 255
            None -= check if i & 1 != 0 else byteval << 8
            if check > oldcheck:
                check -= 1
                continue

        check = (check & 65535) + (check >> 16)
        check = (check & 65535) + (check >> 16)
        checksum = check << 16 & 0xFFFFFFFFL



def initialize():
    log.info('\tloading rendezvous handler: file transfer')
    import oscar.rendezvous.peer as peer
    peer.register_rdv_factory('file_xfer', IncomingOscarFileTransfer)

hooks.Hook('oscar.rdv.load').register(initialize)
if __name__ == '__main__':
    p = 'c:\\users\\kevin\\desktop\\apple_evolution.jpg'
    bytes = open(p, 'rb').read()
    print OFTChecksum(bytes).checksum