X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=youtube_dl%2Fswfinterp.py;h=b63c65b201ec2b34c6482e8526694431041f75fe;hb=27ace98f5159efdf6942e69ec73c5840cce26fbf;hp=49fade364ac8963a713b46eccfcb8e9cd175e893;hpb=0cb2056304178ae8944e84c5bc72f96102291a12;p=youtube-dl

diff --git a/youtube_dl/swfinterp.py b/youtube_dl/swfinterp.py
index 49fade364..b63c65b20 100644
--- a/youtube_dl/swfinterp.py
+++ b/youtube_dl/swfinterp.py
@@ -2,10 +2,13 @@ from __future__ import unicode_literals
 
 import collections
 import io
-import struct
 import zlib
 
-from .utils import ExtractorError
+from .utils import (
+    compat_str,
+    ExtractorError,
+    struct_unpack,
+)
 
 
 def _extract_tags(file_contents):
@@ -20,17 +23,17 @@ def _extract_tags(file_contents):
             file_contents[:1])
 
     # Determine number of bits in framesize rectangle
-    framesize_nbits = struct.unpack('!B', content[:1])[0] >> 3
+    framesize_nbits = struct_unpack('!B', content[:1])[0] >> 3
     framesize_len = (5 + 4 * framesize_nbits + 7) // 8
 
     pos = framesize_len + 2 + 2
     while pos < len(content):
-        header16 = struct.unpack('<H', content[pos:pos + 2])[0]
+        header16 = struct_unpack('<H', content[pos:pos + 2])[0]
         pos += 2
         tag_code = header16 >> 6
         tag_len = header16 & 0x3f
         if tag_len == 0x3f:
-            tag_len = struct.unpack('<I', content[pos:pos + 4])[0]
+            tag_len = struct_unpack('<I', content[pos:pos + 4])[0]
             pos += 4
         assert pos + tag_len <= len(content), \
             ('Tag %d ends at %d+%d - that\'s longer than the file (%d)'
@@ -47,6 +50,17 @@ class _AVMClass_Object(object):
         return '%s#%x' % (self.avm_class.name, id(self))
 
 
+class _ScopeDict(dict):
+    def __init__(self, avm_class):
+        super(_ScopeDict, self).__init__()
+        self.avm_class = avm_class
+
+    def __repr__(self):
+        return '%s__Scope(%s)' % (
+            self.avm_class.name,
+            super(_ScopeDict, self).__repr__())
+
+
 class _AVMClass(object):
     def __init__(self, name_idx, name):
         self.name_idx = name_idx
@@ -55,11 +69,29 @@ class _AVMClass(object):
         self.method_idxs = {}
         self.methods = {}
         self.method_pyfunctions = {}
-        self.variables = {}
+
+        self.variables = _ScopeDict(self)
 
     def make_object(self):
         return _AVMClass_Object(self)
 
+    def __repr__(self):
+        return '_AVMClass(%s)' % (self.name)
+
+    def register_methods(self, methods):
+        self.method_names.update(methods.items())
+        self.method_idxs.update(dict(
+            (idx, name)
+            for name, idx in methods.items()))
+
+
+class _Multiname(object):
+    def __init__(self, kind):
+        self.kind = kind
+
+    def __repr__(self):
+        return '[MULTINAME kind: 0x%x]' % self.kind
+
 
 def _read_int(reader):
     res = 0
@@ -67,7 +99,7 @@ def _read_int(reader):
     for _ in range(5):
         buf = reader.read(1)
         assert len(buf) == 1
-        b = struct.unpack('<B', buf)[0]
+        b = struct_unpack('<B', buf)[0]
         res = res | ((b & 0x7f) << shift)
         if b & 0x80 == 0:
             break
@@ -79,7 +111,7 @@ def _u30(reader):
     res = _read_int(reader)
     assert res & 0xf0000000 == 0
     return res
-u32 = _read_int
+_u32 = _read_int
 
 
 def _s32(reader):
@@ -92,8 +124,8 @@ def _s32(reader):
 def _s24(reader):
     bs = reader.read(3)
     assert len(bs) == 3
-    first_byte = b'\xff' if (ord(bs[0:1]) >= 0x80) else b'\x00'
-    return struct.unpack('!i', first_byte + bs)
+    last_byte = b'\xff' if (ord(bs[2:3]) >= 0x80) else b'\x00'
+    return struct_unpack('<i', bs + last_byte)[0]
 
 
 def _read_string(reader):
@@ -112,7 +144,7 @@ def _read_bytes(count, reader):
 
 def _read_byte(reader):
     resb = _read_bytes(1, reader=reader)
-    res = struct.unpack('<B', resb)[0]
+    res = struct_unpack('<B', resb)[0]
     return res
 
 
@@ -146,10 +178,10 @@ class SWFInterpreter(object):
         double_count = u30()
         read_bytes(max(0, (double_count - 1)) * 8)
         string_count = u30()
-        constant_strings = ['']
+        self.constant_strings = ['']
         for _c in range(1, string_count):
             s = _read_string(code_reader)
-            constant_strings.append(s)
+            self.constant_strings.append(s)
         namespace_count = u30()
         for _c in range(1, namespace_count):
             read_bytes(1)  # kind
@@ -179,9 +211,9 @@ class SWFInterpreter(object):
             if kind == 0x07:
                 u30()  # namespace_idx
                 name_idx = u30()
-                self.multinames.append(constant_strings[name_idx])
+                self.multinames.append(self.constant_strings[name_idx])
             else:
-                self.multinames.append('[MULTINAME kind: %d]' % kind)
+                self.multinames.append(_Multiname(kind))
                 for _c2 in range(MULTINAME_SIZES[kind]):
                     u30()
 
@@ -258,7 +290,11 @@ class SWFInterpreter(object):
         classes = []
         for class_id in range(class_count):
             name_idx = u30()
-            classes.append(_AVMClass(name_idx, self.multinames[name_idx]))
+
+            cname = self.multinames[name_idx]
+            avm_class = _AVMClass(name_idx, cname)
+            classes.append(avm_class)
+
             u30()  # super_name idx
             flags = read_byte()
             if flags & 0x08 != 0:  # Protected namespace is present
@@ -269,7 +305,9 @@ class SWFInterpreter(object):
             u30()  # iinit
             trait_count = u30()
             for _c2 in range(trait_count):
-                parse_traits_info()
+                trait_methods = parse_traits_info()
+                avm_class.register_methods(trait_methods)
+
         assert len(classes) == class_count
         self._classes_by_name = dict((c.name, c) for c in classes)
 
@@ -278,10 +316,7 @@ class SWFInterpreter(object):
             trait_count = u30()
             for _c2 in range(trait_count):
                 trait_methods = parse_traits_info()
-                avm_class.method_names.update(trait_methods.items())
-                avm_class.method_idxs.update(dict(
-                    (idx, name)
-                    for name, idx in trait_methods.items()))
+                avm_class.register_methods(trait_methods)
 
         # Scripts
         script_count = u30()
@@ -331,7 +366,8 @@ class SWFInterpreter(object):
         if func_name in self._classes_by_name:
             return self._classes_by_name[func_name].make_object()
         if func_name not in avm_class.methods:
-            raise ExtractorError('Cannot find function %r' % func_name)
+            raise ExtractorError('Cannot find function %s.%s' % (
+                avm_class.name, func_name))
         m = avm_class.methods[func_name]
 
         def resfunc(args):
@@ -340,17 +376,22 @@ class SWFInterpreter(object):
             s24 = lambda: _s24(coder)
             u30 = lambda: _u30(coder)
 
-            print('Invoking %s.%s(%r)' % (avm_class.name, func_name, tuple(args)))
-            registers = ['(this)'] + list(args) + [None] * m.local_count
+            registers = [avm_class.variables] + list(args) + [None] * m.local_count
             stack = []
+            scopes = collections.deque([
+                self._classes_by_name, avm_class.variables])
             while True:
                 opcode = _read_byte(coder)
-                print('opcode: %r, stack(%d): %r' % (opcode, len(stack), stack))
                 if opcode == 17:  # iftrue
                     offset = s24()
                     value = stack.pop()
                     if value:
                         coder.seek(coder.tell() + offset)
+                elif opcode == 18:  # iffalse
+                    offset = s24()
+                    value = stack.pop()
+                    if not value:
+                        coder.seek(coder.tell() + offset)
                 elif opcode == 36:  # pushbyte
                     v = _read_byte(coder)
                     stack.append(v)
@@ -359,11 +400,17 @@ class SWFInterpreter(object):
                     stack.append(value)
                 elif opcode == 44:  # pushstring
                     idx = u30()
-                    stack.append(constant_strings[idx])
+                    stack.append(self.constant_strings[idx])
                 elif opcode == 48:  # pushscope
-                    # We don't implement the scope register, so we'll just
-                    # ignore the popped value
                     new_scope = stack.pop()
+                    scopes.append(new_scope)
+                elif opcode == 66:  # construct
+                    arg_count = u30()
+                    args = list(reversed(
+                        [stack.pop() for _ in range(arg_count)]))
+                    obj = stack.pop()
+                    res = obj.avm_class.make_object()
+                    stack.append(res)
                 elif opcode == 70:  # callproperty
                     index = u30()
                     mname = self.multinames[index]
@@ -371,33 +418,46 @@ class SWFInterpreter(object):
                     args = list(reversed(
                         [stack.pop() for _ in range(arg_count)]))
                     obj = stack.pop()
-                    if mname == 'split':
-                        assert len(args) == 1
-                        assert isinstance(args[0], compat_str)
-                        assert isinstance(obj, compat_str)
-                        if args[0] == '':
-                            res = list(obj)
-                        else:
-                            res = obj.split(args[0])
-                        stack.append(res)
-                    elif mname == 'slice':
-                        assert len(args) == 1
-                        assert isinstance(args[0], int)
-                        assert isinstance(obj, list)
-                        res = obj[args[0]:]
+
+                    if isinstance(obj, _AVMClass_Object):
+                        func = self.extract_function(obj.avm_class, mname)
+                        res = func(args)
                         stack.append(res)
-                    elif mname == 'join':
-                        assert len(args) == 1
-                        assert isinstance(args[0], compat_str)
-                        assert isinstance(obj, list)
-                        res = args[0].join(obj)
+                        continue
+                    elif isinstance(obj, _ScopeDict):
+                        if mname in obj.avm_class.method_names:
+                            func = self.extract_function(obj.avm_class, mname)
+                            res = func(args)
+                        else:
+                            res = obj[mname]
                         stack.append(res)
-                    elif mname in avm_class.method_pyfunctions:
-                        stack.append(avm_class.method_pyfunctions[mname](args))
-                    else:
-                        raise NotImplementedError(
-                            'Unsupported property %r on %r'
-                            % (mname, obj))
+                        continue
+                    elif isinstance(obj, compat_str):
+                        if mname == 'split':
+                            assert len(args) == 1
+                            assert isinstance(args[0], compat_str)
+                            if args[0] == '':
+                                res = list(obj)
+                            else:
+                                res = obj.split(args[0])
+                            stack.append(res)
+                            continue
+                    elif isinstance(obj, list):
+                        if mname == 'slice':
+                            assert len(args) == 1
+                            assert isinstance(args[0], int)
+                            res = obj[args[0]:]
+                            stack.append(res)
+                            continue
+                        elif mname == 'join':
+                            assert len(args) == 1
+                            assert isinstance(args[0], compat_str)
+                            res = args[0].join(obj)
+                            stack.append(res)
+                            continue
+                    raise NotImplementedError(
+                        'Unsupported property %r on %r'
+                        % (mname, obj))
                 elif opcode == 72:  # returnvalue
                     res = stack.pop()
                     return res
@@ -409,11 +469,11 @@ class SWFInterpreter(object):
                     obj = stack.pop()
 
                     mname = self.multinames[index]
-                    construct_method = self.extract_function(
-                        obj.avm_class, mname)
+                    assert isinstance(obj, _AVMClass)
+
                     # We do not actually call the constructor for now;
                     # we just pretend it does nothing
-                    stack.append(obj)
+                    stack.append(obj.make_object())
                 elif opcode == 79:  # callpropvoid
                     index = u30()
                     mname = self.multinames[index]
@@ -438,22 +498,42 @@ class SWFInterpreter(object):
                 elif opcode == 93:  # findpropstrict
                     index = u30()
                     mname = self.multinames[index]
-                    res = self.extract_function(avm_class, mname)
-                    stack.append(res)
+                    for s in reversed(scopes):
+                        if mname in s:
+                            res = s
+                            break
+                    else:
+                        res = scopes[0]
+                    stack.append(res[mname])
                 elif opcode == 94:  # findproperty
                     index = u30()
                     mname = self.multinames[index]
-                    res = avm_class.variables.get(mname)
+                    for s in reversed(scopes):
+                        if mname in s:
+                            res = s
+                            break
+                    else:
+                        res = avm_class.variables
                     stack.append(res)
                 elif opcode == 96:  # getlex
                     index = u30()
                     mname = self.multinames[index]
-                    res = avm_class.variables.get(mname, None)
+                    for s in reversed(scopes):
+                        if mname in s:
+                            scope = s
+                            break
+                    else:
+                        scope = avm_class.variables
+                    # I cannot find where static variables are initialized
+                    # so let's just return None
+                    res = scope.get(mname)
                     stack.append(res)
                 elif opcode == 97:  # setproperty
                     index = u30()
                     value = stack.pop()
                     idx = self.multinames[index]
+                    if isinstance(idx, _Multiname):
+                        idx = stack.pop()
                     obj = stack.pop()
                     obj[idx] = value
                 elif opcode == 98:  # getlocal
@@ -512,6 +592,10 @@ class SWFInterpreter(object):
                     stack.append(registers[2])
                 elif opcode == 211:  # getlocal_3
                     stack.append(registers[3])
+                elif opcode == 212:  # setlocal_0
+                    registers[0] = stack.pop()
+                elif opcode == 213:  # setlocal_1
+                    registers[1] = stack.pop()
                 elif opcode == 214:  # setlocal_2
                     registers[2] = stack.pop()
                 elif opcode == 215:  # setlocal_3