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