home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / oscar / OscarUtil.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  15.7 KB  |  477 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from peak.util.imports import lazyModule
  5. from util.primitives import odict
  6. import struct
  7. util = lazyModule('util')
  8. auxencodings = lazyModule('util.auxencodings')
  9. import sys
  10. import array
  11. import logging
  12. import string
  13. from collections import defaultdict
  14. import oscar
  15. log = logging.getLogger('oscar.util')
  16.  
  17. flagged = lambda f, v: f & v == f
  18. len_to_fmt = {
  19.     0: '',
  20.     1: 'B',
  21.     2: 'H',
  22.     4: 'I',
  23.     8: 'Q',
  24.     16: '16s' }
  25.  
  26. def lowerstrip(s):
  27.     return s.lower().replace(' ', '')
  28.  
  29.  
  30. def tflv(type_, flags = 1, data = ''):
  31.     return struct.pack('!HBB', type_, flags, len(data)) + data
  32.  
  33.  
  34. def tflv_list(*tflvs):
  35.     return ''.join((lambda .0: for t in .0:
  36. tflv(*t))(tflvs))
  37.  
  38.  
  39. def tlv(type_, length = 0, value = 0):
  40.     if isinstance(length, basestring):
  41.         value = length
  42.         length = len(value)
  43.     elif not isinstance(value, (int, long)):
  44.         raise AssertionError('%r is not an integer' % value)
  45.     
  46.     if isinstance(value, basestring):
  47.         fmt_string = None if value else ''
  48.     else:
  49.         fmt_string = len_to_fmt[length]
  50.     args = [
  51.         type_]
  52.     None += args if length else [
  53.         0]
  54.     if value:
  55.         pass
  56.     elif length:
  57.         pass
  58.     
  59.     args += []
  60.     
  61.     try:
  62.         return struct.pack('!HH' + fmt_string, *args)
  63.     except Exception:
  64.         print fmt_string, args
  65.         raise 
  66.  
  67.  
  68.  
  69. def tlv_list(*tlvs):
  70.     return ''.join((lambda .0: for t in .0:
  71. tlv(*t))(tlvs))
  72.  
  73.  
  74. def s_tlv(data, byte_order = '!'):
  75.     (t, l) = struct.unpack(byte_order + 'HH', data[:4])
  76.     data = data[4:]
  77.     v = data[:l]
  78.     data = data[l:]
  79.     return (util.Storage(t = t, l = l, v = v), data)
  80.  
  81.  
  82. def tlv_list_to_dict(tlv_list):
  83.     return odict((lambda .0: for tlv in .0:
  84. (tlv.t, tlv.v))(tlv_list))
  85.  
  86.  
  87. def s_tflv(data, byte_order = '!'):
  88.     fmt = (('type', 'H'), ('flags', 'B'), ('length', 'B'), ('value', 's', 'length'))
  89.     (t, f, l, v, data) = apply_format(fmt, data)
  90.     return (util.Storage(t = t, f = f, l = l, v = v), data)
  91.  
  92.  
  93. def list_reader(of_what, byte_order = '!'):
  94.     
  95.     def read_list(data, count = (None, -1)):
  96.         objs = []
  97.         while data and count:
  98.             (thing, data) = of_what(data, byte_order)
  99.             objs.append(thing)
  100.             
  101.             try:
  102.                 count -= 1
  103.             continue
  104.             except TypeError:
  105.                 print count
  106.                 raise 
  107.                 continue
  108.             
  109.  
  110.             None<EXCEPTION MATCH>TypeError
  111.         return (objs, data)
  112.  
  113.     return read_list
  114.  
  115. s_tflv_list = list_reader(s_tflv)
  116. s_tlv_list = list_reader(s_tlv)
  117.  
  118. def decode(s, enc):
  119.     if enc.find('; charset="') != -1:
  120.         (msgtype, encoding) = enc.split('; charset="')
  121.         encoding = encoding[:-1]
  122.     else:
  123.         log.warning('oscar.decode encountered "%s", no charset--assuming utf-8', enc)
  124.         encoding = 'utf-8'
  125.     encoding = encoding.split('\x00', 1)[0]
  126.     encodings = {
  127.         'unicode-2-0': 'utf-16be',
  128.         'utf-8': 'utf-8',
  129.         'us-ascii': 'ascii' }
  130.     encoding = encodings.get(encoding, encoding)
  131.     return auxencodings.fuzzydecode(s, encoding)
  132.  
  133. struct_types = set('xcbhilqfdsp')
  134. oscar_types = set([
  135.     'tlv',
  136.     'tlv_list',
  137.     'tlv_dict',
  138.     'named_tlvs',
  139.     'list',
  140.     'tflv',
  141.     'tflv_list',
  142.     'rate_class_list',
  143.     'rate_group_list',
  144.     'pstring',
  145.     'message_block',
  146.     'ssi_dict',
  147.     'ssi',
  148.     'tlv_list_len',
  149.     'tlv_dict_len',
  150.     'userinfo',
  151.     'dc_info',
  152.     'rate_class',
  153.     'msg_fragment',
  154.     'lnts'])
  155. all_format_types = struct_types | oscar_types
  156. digits = set(string.digits)
  157.  
  158. def apply_format(format, data, byte_order = '!'):
  159.     if not isinstance(format, (tuple, list)) and isinstance(format[0], (tuple, list)):
  160.         raise TypeError('apply_format needs a tuple of tuples')
  161.     isinstance(format[0], (tuple, list))
  162.     fields = { }
  163.     to_return = []
  164.     for item in format:
  165.         name = item[0]
  166.         kind = item[1]
  167.         args = item[2:]
  168.         skind = kind
  169.         while len(skind) > 0 and skind[0] in digits:
  170.             skind = skind[1:]
  171.         if kind.lower() in oscar_types:
  172.             f = globals().get('apply_format_%s' % kind, None)
  173.             if f is None:
  174.                 raise Exception('%r is not a valid format type' % kind)
  175.             f is None
  176.             (fields[name], data) = f(data, fields, byte_order, *args)
  177.             to_return.append(fields[name])
  178.             continue
  179.         
  180.         prev_name = None if args else None
  181.         if prev_name is not None:
  182.             fmt = None % ('%d%s' if isinstance(prev_name, int) else fields[prev_name], kind)
  183.         else:
  184.             fmt = kind
  185.         fmt = byte_order + fmt
  186.         
  187.         try:
  188.             sz = struct.calcsize(fmt)
  189.         except Exception:
  190.             print 'BAD FORMAT:', fmt
  191.             raise 
  192.  
  193.         
  194.         try:
  195.             fields[name] = struct.unpack(fmt, data[:sz])
  196.         except Exception:
  197.             print name, fmt, util.to_hex(data)
  198.             raise 
  199.  
  200.         if len(fields[name]) == 1:
  201.             fields[name] = fields[name][0]
  202.         
  203.         data = data[sz:]
  204.         to_return.append(fields[name])
  205.     
  206.     to_return.append(data)
  207.     return to_return
  208.  
  209.  
  210. def apply_format_tlv(data, fields, byte_order):
  211.     return s_tlv(data)
  212.  
  213.  
  214. def apply_format_tlv_dict(data, fields, byte_order, num_tlvs_s = -1):
  215.     (tlvs, data) = apply_format_tlv_list(data, fields, byte_order, num_tlvs_s)
  216.     return (tlv_list_to_dict(tlvs), data)
  217.  
  218.  
  219. def apply_format_tlv_dict_len(data, fields, byte_order, byte_count_s):
  220.     (tlvs, data) = apply_format_tlv_list_len(data, fields, byte_order, byte_count_s)
  221.     return (tlv_list_to_dict(tlvs), data)
  222.  
  223.  
  224. def apply_format_tlv_list(data, fields, byte_order, num_tlvs_s = -1):
  225.     if isinstance(num_tlvs_s, basestring):
  226.         num_tlvs = fields[num_tlvs_s]
  227.     else:
  228.         num_tlvs = num_tlvs_s
  229.     return s_tlv_list(data, num_tlvs)
  230.  
  231.  
  232. def apply_format_tlv_list_len(data, fields, byte_order, byte_count_s):
  233.     if isinstance(byte_count_s, basestring):
  234.         byte_count = fields[byte_count_s]
  235.     else:
  236.         byte_count = byte_count_s
  237.     indata = data[:byte_count]
  238.     rdata = data[byte_count:]
  239.     (tlvs, outdata) = apply_format_tlv_list(indata, fields, byte_order, -1)
  240.     return (tlvs, rdata)
  241.  
  242.  
  243. def apply_format_named_tlvs(data, fields, byte_order, tlv_count_s, tlv_types):
  244.     if isinstance(tlv_count_s, basestring):
  245.         tlv_count = fields[tlv_count_s]
  246.     else:
  247.         tlv_count = tlv_count_s
  248.     (tlvs, data) = s_tlv_list(data, tlv_count)
  249.     bynumber = tlv_list_to_dict(tlvs)
  250.     named_tlvs = util.Storage()
  251.     for type, tlv in bynumber.iteritems():
  252.         named_tlvs[tlv_types.get(type, type)] = tlv
  253.     
  254.     return (named_tlvs, data)
  255.  
  256.  
  257. def apply_format_tflv(data, fields, byte_order):
  258.     return s_tflv(data)
  259.  
  260.  
  261. def apply_format_tflv_list(data, fields, byte_order, num_tflvs_s = -1):
  262.     if isinstance(num_tflvs_s, basestring):
  263.         num_tflvs = fields[num_tflvs_s]
  264.     else:
  265.         num_tflvs = num_tflvs_s
  266.     return s_tflv_list(data, num_tflvs)
  267.  
  268.  
  269. def apply_format_userinfo(data, fields, byte_order):
  270.     userinfo_types = {
  271.         1: 'user_class',
  272.         2: 'create_time',
  273.         3: 'signon_time',
  274.         4: 'idle_time',
  275.         5: 'account_creation_time',
  276.         6: 'user_status_icq',
  277.         10: 'external_ip_icq',
  278.         12: 'dc_info',
  279.         13: 'capabilities',
  280.         15: 'online_time',
  281.         29: 'avail_msg',
  282.         35: 'profile_updated',
  283.         38: 'mystery_updated',
  284.         39: 'away_updated' }
  285.     fmt = (('sn', 'pstring'), ('warning', 'H'), ('num_tlvs', 'H'), ('tlvs', 'named_tlvs', 'num_tlvs', userinfo_types))
  286.     (sn, warning, __, userdict, data) = apply_format(fmt, data)
  287.     userdict.nice_name = sn
  288.     userdict.name = sn.lower().replace(' ', '')
  289.     userdict.warning_level = warning
  290.     return (userdict, data)
  291.  
  292.  
  293. def apply_format_dc_info(data, fields, byte_order):
  294.     names = 'ip port type version cookie web_port features info_update_time '.split()
  295.     sizes = '4B I    B    H       I      I        I        I                '.split()
  296.     names += 'ext_update_time status_update_time unknown'.split()
  297.     sizes += 'I               I                  H      '.split()
  298.     stuff = apply_format(zip(names, sizes), data)
  299.     return (util.Storage(zip(names, stuff[:-1])), data[-1])
  300.  
  301.  
  302. def apply_format_list(data, fields, byte_order, kind, count_s = -1):
  303.     if isinstance(count_s, basestring):
  304.         count = fields[count_s]
  305.     else:
  306.         count = count_s
  307.     result = []
  308.     while data and count:
  309.         (info, data) = apply_format((('info', kind),), data, byte_order)
  310.         result.append(info)
  311.         count -= 1
  312.     return (result, data)
  313.  
  314.  
  315. def apply_format_rate_class(data, fields, byte_order):
  316.     fmt_str1 = 'id               H window           I clear_level      I alert_level      I limit_level      I disconnect_level I current_level    I max_level        I last_time        I state            B'.split()
  317.     rate_class_fmt = zip(fmt_str1[::2], fmt_str1[1::2])
  318.     info = apply_format(rate_class_fmt, data, byte_order)
  319.     data = info.pop()
  320.     rate_class = util.Storage(zip(fmt_str1[::2], info))
  321.     return (rate_class, data)
  322.  
  323.  
  324. def apply_format_rate_class_list(data, fields, byte_order, num_classes_s):
  325.     if isinstance(num_classes_s, basestring):
  326.         num_classes = fields[num_classes_s]
  327.     else:
  328.         num_classes = num_classes_s
  329.     classes = []
  330.     while data and num_classes:
  331.         (rate_class, data) = apply_format_rate_class(data, fields, byte_order)
  332.         classes.append(rate_class)
  333.         num_classes -= 1
  334.     return (classes, data)
  335.  
  336.  
  337. def apply_format_pstring(data, fields, byte_order):
  338.     l = struct.unpack('B', data[:1])[0]
  339.     string_ = struct.unpack(str(l) + 's', data[1:1 + l])[0]
  340.     return (string_, data[l + 1:])
  341.  
  342.  
  343. def apply_format_message_block(data, fields, byte_order):
  344.     msg = util.Storage()
  345.     fmt = (('msg_fragments', 'list', 'msg_fragment'),)
  346.     (msg_fragments, data) = apply_format(fmt, data)
  347.     msgs = _[1]
  348.     res = dict(msg_fragments)
  349.     return (res, data)
  350.  
  351.  
  352. def apply_format_msg_fragment(data, fields, byte_order):
  353.     fmt = (('type', 'B'), ('version', 'B'), ('length', 'H'), ('data', 's', 'length'))
  354.     (type, __, __, data, remaining_data) = apply_format(fmt, data, byte_order)
  355.     return ((type, data), remaining_data)
  356.  
  357.  
  358. def apply_format_rate_group(data, fields, byte_order):
  359.     _data = data[:]
  360.     rate_group_fmt = (('id', 'H'), ('num_pairs', 'H'), ('pairs_list', 'list', 'I', 'num_pairs'))
  361.     
  362.     try:
  363.         stuff = apply_format(rate_group_fmt, data, byte_order)
  364.     except ValueError:
  365.         e = None
  366.         stuff = apply_format(rate_group_fmt, _data, '<')
  367.  
  368.     (id, num_pairs, pairs_list, data) = stuff
  369.     pairs = []
  370.     for pair in pairs_list:
  371.         (fam, sub) = struct.unpack(byte_order + 'HH', struct.pack(byte_order + 'I', pair))
  372.         pairs.append((fam, sub))
  373.     
  374.     return (dict.fromkeys(pairs, id), data)
  375.  
  376.  
  377. def apply_format_rate_group_list(data, fields, byte_order, num_groups_s):
  378.     if isinstance(num_groups_s, basestring):
  379.         num_groups = fields[num_groups_s]
  380.     else:
  381.         num_groups = num_groups_s
  382.     rate_groups = { }
  383.     while data and num_groups:
  384.         (rate_group, data) = apply_format_rate_group(data, fields, byte_order)
  385.         rate_groups.update(rate_group)
  386.         num_groups -= 1
  387.     return (rate_groups, data)
  388.  
  389.  
  390. def apply_format_ssi(data, fields, byte_order):
  391.     ssi_fmt = (('name_len', 'H'), ('name', 's', 'name_len'), ('group_id', 'H'), ('item_id', 'H'), ('type_', 'H'), ('data_len', 'H'), ('tlvs', 'tlv_dict_len', 'data_len'))
  392.     (__, name, group_id, item_id, type_, __, tlvs, data) = apply_format(ssi_fmt, data, byte_order)
  393.     return (oscar.ssi.item(name, group_id, item_id, type_, tlvs), data)
  394.  
  395.  
  396. def apply_format_ssi_list(data, fields, byte_order, num_ssis_s = -1):
  397.     if isinstance(num_ssis_s, basestring):
  398.         num_ssis = fields[num_ssis_s]
  399.     else:
  400.         num_ssis = num_ssis_s
  401.     l = []
  402.     while data and num_ssis != 0:
  403.         (ssi, data) = apply_format_ssi(data, fields, byte_order)
  404.         l.append(ssi)
  405.         num_ssis -= 1
  406.     return (l, data)
  407.  
  408.  
  409. def apply_format_ssi_dict(*args):
  410.     (l, data) = apply_format_ssi_list(*args)
  411.     d = { }
  412.     for item in l:
  413.         d[(item.group_id, item.item_id)] = item
  414.     
  415.     return (d, data)
  416.  
  417.  
  418. def apply_format_lnts(data, fields, byte_order = '<'):
  419.     if byte_order != '<':
  420.         import warnings
  421.         warnings.warn('oscar.apply_format_lnts got a byte order other than little-endian')
  422.     
  423.     length = struct.unpack(byte_order + 'H', data[:2])[0]
  424.     data = data[2:]
  425.     val = data[:length]
  426.     data = data[length:]
  427.     if length:
  428.         pass
  429.     
  430.     return (val[:-1], data)
  431.  
  432.  
  433. def chat_cookie(room_name, exchange = 4):
  434.     cookie = '!aol://2719:10-' + str(exchange) + '-' + str(room_name.replace(' ', '').lower())
  435.     return cookie
  436.  
  437.  
  438. def process_status_bits(user_status_icq):
  439.     offline = 0xFFFFFFFFL
  440.     webaware = 65536
  441.     invisible = 256
  442.     dnd = 2
  443.     busy = 16
  444.     na = 4
  445.     away = 1
  446.     ffc = 32
  447.     online = 0
  448.     webaware = False
  449.     status = None
  450.     (flags, status_bits) = struct.unpack('!HH', user_status_icq)
  451.     webaware = flagged(webaware, status_bits)
  452.     if flagged(offline, status_bits):
  453.         status = 'offline'
  454.     elif flagged(invisible, status_bits):
  455.         status = 'invisible'
  456.     elif flagged(dnd, status_bits):
  457.         status = 'do not disturb'
  458.     elif flagged(busy, status_bits):
  459.         status = 'busy'
  460.     elif flagged(na, status_bits):
  461.         status = 'not available'
  462.     elif flagged(away, status_bits):
  463.         status = 'away'
  464.     elif flagged(ffc, status_bits):
  465.         status = 'free for chat'
  466.     elif flagged(online, status_bits):
  467.         status = 'available'
  468.     
  469.     return (status, webaware)
  470.  
  471.  
  472. def is_chat_cookie(cookie):
  473.     if not isinstance(cookie, basestring) and cookie.startswith('aol://'):
  474.         pass
  475.     return cookie.startswith('!aol://')
  476.  
  477.