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