예제 #1
0
 def __call__(self, prev):
     name = self.path + "[]"
     address, size, last = self.cluster.next()
     if self.filesize:
         if self.done >= self.filesize:
             error("(FAT) bad metadata for " + self.path)
             return
         field = File(self.root, name, size=size)
         if prev.first is None:
             field._description = 'File size: %s' % humanFilesize(self.filesize//8)
             field.setSubIStream(self.createInputStream)
         field.datasize = min(self.filesize - self.done, size)
         self.done += field.datasize
     else:
         field = Directory(self.root, name, size=size)
     padding = self.root.getFieldByAddress(address, feed=False)
     if not isinstance(padding, (PaddingBytes, RawBytes)):
         error("(FAT) address %u doesn't point to a padding field" % address)
         return
     if last:
         next = None
     else:
         next = lambda: self(field)
     field.setLinks(prev.first, next)
     self.root.writeFieldsIn(padding, address, (field,))
     return field
예제 #2
0
 def _getContentSize(self):
     if not hasattr(self, "_content_size"):
         try:
             self._content_size = self.createContentSize()
         except HACHOIR_ERRORS, err:
             error("Unable to compute %s content size: %s" % (self.__class__.__name__, err))
             self._content_size = None
예제 #3
0
 def _getContentSize(self):
     if not hasattr(self, "_content_size"):
         try:
             self._content_size = self.createContentSize()
         except HACHOIR_ERRORS, err:
             error("Unable to compute %s content size: %s" %
                   (self.__class__.__name__, err))
             self._content_size = None
예제 #4
0
 def _getDescription(self):
     if self._description is None:
         try:
             self._description = self.createDescription()
             if isinstance(self._description, str):
                 self._description = makeUnicode(self._description)
         except HACHOIR_ERRORS, err:
             error("Error getting description of %s: %s" \
                 % (self.path, unicode(err)))
             self._description = self.PARSER_TAGS["description"]
예제 #5
0
 def _getDescription(self):
     if self._description is None:
         try:
             self._description = self.createDescription()
             if isinstance(self._description, str):
                 self._description = makeUnicode(self._description)
         except HACHOIR_ERRORS, err:
             error("Error getting description of %s: %s" \
                 % (self.path, unicode(err)))
             self._description = self.PARSER_TAGS["description"]
예제 #6
0
def processFile(filename, quality=0.5):
    charset = getTerminalCharset()
    filename, real_filename = unicodeFilename(filename, charset), filename

    # Create parser
    try:
        tags = None
        parser = createParser(filename, real_filename=real_filename, tags=tags)
    except InputStreamError, err:
        error(unicode(err))
        return False
예제 #7
0
def getMetaDataOther(values, filename, display_filename=False, priority=None, human=True, display=True, charset='utf-8'):
    real_filename = filename

    # Create parser
    try:
        if values['force_parser']:
            tags = [("id", values['force_parser']), None]
        else:
            tags = None
        parser = createParser(filename, real_filename=real_filename, tags=tags)
    except InputStreamError, err:
        error(unicode(err))
        return False
예제 #8
0
def processFileReturn(filename, display_filename=False, priority=None, human=True, display=True):
    charset = getTerminalCharset()
    # filename, real_filename = unicode(filename, charset), filename
    if type(filename) == str:
        filename, real_filename = unicodeFilename(filename, charset), filename
    else:
        real_filename = filename.encode(getTerminalCharset())
    try:
        parser = createParser(filename, real_filename=real_filename, tags=None)
    except InputStreamError, err:
        error(unicode(err))
        try: del(parser)
        except: pass
        return False
예제 #9
0
def extractMetadata(parser, quality=QUALITY_NORMAL):
    """
    Create a Metadata class from a parser. Returns None if no metadata
    extractor does exist for the parser class.
    """
    try:
        extractor = extractors[parser.__class__]
    except KeyError:
        return None
    metadata = extractor(quality)
    try:
        metadata.extract(parser)
    except HACHOIR_ERRORS, err:
        error("Error during metadata extraction: %s" % unicode(err))
예제 #10
0
def extractMetadata(parser, quality=QUALITY_NORMAL):
    """
    Create a Metadata class from a parser. Returns None if no metadata
    extractor does exist for the parser class.
    """
    try:
        extractor = extractors[parser.__class__]
    except KeyError:
        return None
    metadata = extractor(quality)
    try:
        metadata.extract(parser)
    except HACHOIR_ERRORS, err:
        error("Error during metadata extraction: %s" % unicode(err))
예제 #11
0
def processFile(values, filename,
display_filename=False, priority=None, human=True, display=True):
    charset = getTerminalCharset()
    filename, real_filename = unicodeFilename(filename, charset), filename

    # Create parser
    try:
        if values.force_parser:
            tags = [ ("id", values.force_parser), None ]
        else:
            tags = None
        parser = createParser(filename, real_filename=real_filename, tags=tags)
    except InputStreamError, err:
        error(unicode(err))
        return False
예제 #12
0
    def writeFile(self, filename, stream, offset, size):
        # Create directory (only on first call)
        if not self.mkdir:
            self.createDirectory()
            self.mkdir = True

        # Create output file
        filename, real_filename = path.join(self.directory_unicode, filename), \
                                  path.join(self.directory_raw, filename)
        output = FileOutputStream(filename, real_filename=real_filename)

        # Write output
        try:
            output.copyBytesFrom(stream, offset, size // 8)
        except StreamError, err:
            error(u"copyBytesFrom() error: %s" % err)
예제 #13
0
파일: output.py 프로젝트: Woerd88/hachoir
    def writeFile(self, filename, stream, offset, size):
        # Create directory (only on first call)
        if not self.mkdir:
            self.createDirectory()
            self.mkdir = True

        # Create output file
        filename, real_filename = path.join(self.directory_unicode, filename), \
                                  path.join(self.directory_raw, filename)
        output = FileOutputStream(filename, real_filename=real_filename)

        # Write output
        try:
            output.copyBytesFrom(stream, offset, size//8)
        except StreamError, err:
            error(u"copyBytesFrom() error: %s" % err)
예제 #14
0
def processFile(values,
                filename,
                display_filename=False,
                priority=None,
                human=True,
                display=True):
    charset = getTerminalCharset()
    filename, real_filename = unicodeFilename(filename, charset), filename

    # Create parser
    try:
        if values.force_parser:
            tags = [("id", values.force_parser), None]
        else:
            tags = None
        parser = createParser(filename, real_filename=real_filename, tags=tags)
    except InputStreamError, err:
        error(unicode(err))
        return False
예제 #15
0
def extractMetadata(parser, quality=QUALITY_NORMAL, **kwargs):
    """
    Create a Metadata class from a parser. Returns None if no metadata
    extractor does exist for the parser class.
    """
    try:
        extractor = extractors[parser.__class__]
    except KeyError:
        return None
    metadata = extractor(quality)
    meta_extract_error = True
    try:
        if 'scan_index' in kwargs:
            metadata.extract(parser, scan_index=kwargs['scan_index'])
        else:
            metadata.extract(parser)
        meta_extract_error = False
    except HACHOIR_ERRORS, err:
        error("Error during metadata extraction: %s" % unicode(err))
예제 #16
0
def processFileReturn(filename,
                      display_filename=False,
                      priority=None,
                      human=True,
                      display=True):
    charset = getTerminalCharset()
    # filename, real_filename = unicode(filename, charset), filename
    if type(filename) == str:
        filename, real_filename = unicodeFilename(filename, charset), filename
    else:
        real_filename = filename.encode(getTerminalCharset())
    try:
        parser = createParser(filename, real_filename=real_filename, tags=None)
    except InputStreamError, err:
        error(unicode(err))
        try:
            del (parser)
        except:
            pass
        return False
예제 #17
0
    def add(self, parser):
        tags = parser.getParserTags()
        err = self.validParser(parser, tags)
        if err:
            error("Skip parser %s: %s" % (parser.__name__, err))
            return

        _tags = []
        for tag in tags.iteritems():
            tag = self.translate(*tag)
            if isinstance(tag, tuple):
                _tags.append(tag)
            elif tag is not True:
                error("[%s] %s" % (parser.__name__, tag))
                return

        self.parser_list.append(parser)

        for name, values in _tags:
            byname = self.bytag.setdefault(name,{})
            for value in values:
                byname.setdefault(value,[]).append(parser)
예제 #18
0
def testRandom(seed=0, tests=(1,8)):
    random.seed(seed)
    a = array('L')
    parser_list = HachoirParserList()
    n = max(tests) * max(parser.getParserTags()["min_size"] for parser in parser_list)
    k = 8 * a.itemsize
    for i in xrange((n - 1) // k + 1):
        a.append(random.getrandbits(k))
    a = StringInputStream(a.tostring(), source="<random data>")
    ok = True
    for parser in parser_list:
        size = parser.getParserTags()["min_size"]
        for test in tests:
            a._size = a._current_size = size * test
            try:
                parser(a, validate=True)
                error("[%s] Parser didn't reject random data" % parser.__name__)
            except ValidateError:
                continue
            except HACHOIR_ERRORS, err:
                error(u"[%s] %s" % (parser.__name__, err))
            ok = False
def testRandom(seed=0, tests=(1,8)):
    random.seed(seed)
    a = array('L')
    parser_list = HachoirParserList()
    n = max(tests) * max(parser.getParserTags()["min_size"] for parser in parser_list)
    k = 8 * a.itemsize
    for i in xrange((n - 1) // k + 1):
        a.append(random.getrandbits(k))
    a = StringInputStream(a.tostring(), source="<random data>")
    ok = True
    for parser in parser_list:
        size = parser.getParserTags()["min_size"]
        for test in tests:
            a._size = a._current_size = size * test
            try:
                parser(a, validate=True)
                error("[%s] Parser didn't reject random data" % parser.__name__)
            except ValidateError:
                continue
            except HACHOIR_ERRORS, err:
                error(u"[%s] %s" % (parser.__name__, err))
            ok = False
예제 #20
0
 # filename, real_filename = unicode(filename, charset), filename
 if type(filename) == str:
     filename, real_filename = unicodeFilename(filename, charset), filename
 else:
     real_filename = filename.encode(getTerminalCharset())
 try:
     parser = createParser(filename, real_filename=real_filename, tags=None)
 except InputStreamError, err:
     error(unicode(err))
     try:
         del (parser)
     except:
         pass
     return False
 if not parser:
     error(_("Unable to parse file: %s") % filename)
     try:
         del (parser)
     except:
         pass
     return False
 try:
     metadata = extractMetadata(parser, 1.0)
 except HachoirError, err:
     error(unicode(err))
     metadata = None
 if not metadata:
     parser.error(
         _("Hachoir can't extract metadata, but is able to parse: %s") %
         filename)
     try:
예제 #21
0
파일: metadata.py 프로젝트: feld/SickRage

def registerExtractor(parser, extractor):
    assert parser not in extractors
    assert issubclass(extractor, RootMetadata)
    extractors[parser] = extractor


def extractMetadata(parser, quality=QUALITY_NORMAL):
    """
    Create a Metadata class from a parser. Returns None if no metadata
    extractor does exist for the parser class.
    """
    try:
        extractor = extractors[parser.__class__]
    except KeyError:
        return None
    metadata = extractor(quality)
    try:
        metadata.extract(parser)
    except HACHOIR_ERRORS, err:
        error("Error during metadata extraction: %s" % unicode(err))
        return None
    except Exception, err:
        error("Error during metadata extraction: %s" % unicode(err))
        return None
    if metadata:
        metadata.mime_type = parser.mime_type
        metadata.endian = endian_name[parser.endian]
    return metadata
예제 #22
0
                for field in object[struct.name]:
                    print "%08X: %s = %s" % ((object.address + struct.address + field.address)/8, field.path, field.display)
            else:
                 print "%08X: %s = %s" % ((struct.address)/8, struct.path, struct.display)

        object = data["raw_file_info"]
        for struct in object:
            print "%08X: %s = %s" % ((object.address + struct.address)/8, struct.path, struct.display)
            try:
                iter_exists = getattr(struct, "__iter__", None)
            except AttributeError:
                pass
            if iter_exists:
                for field in object[struct.name]:
                    print "%08X: %s = %s" % ((object.address + struct.address + field.address)/8, field.path, field.display)
            else:
                 print "%08X: %s = %s" % ((struct.address)/8, struct.path, struct.display)

        object = data["trailer"]
        print "%08X: %s = %s" % ((object.address)/8, object.path, object.display)

    except ValidateError, err:
        error(u"%s" % (err))

    # except HACHOIR_ERRORS, err:
    #     error(u"%s" % (err))

if __name__ == "__main__":
    main()

예제 #23
0
        object = data["raw_file_info"]
        for struct in object:
            print "%08X: %s = %s" % ((object.address + struct.address) / 8,
                                     struct.path, struct.display)
            try:
                iter_exists = getattr(struct, "__iter__", None)
            except AttributeError:
                pass
            if iter_exists:
                for field in object[struct.name]:
                    print "%08X: %s = %s" % (
                        (object.address + struct.address + field.address) / 8,
                        field.path, field.display)
            else:
                print "%08X: %s = %s" % (
                    (struct.address) / 8, struct.path, struct.display)

        object = data["trailer"]
        print "%08X: %s = %s" % (
            (object.address) / 8, object.path, object.display)

    except ValidateError, err:
        error(u"%s" % (err))

    # except HACHOIR_ERRORS, err:
    #     error(u"%s" % (err))


if __name__ == "__main__":
    main()
예제 #24
0
    extractor does exist for the parser class.
    """
    try:
        extractor = extractors[parser.__class__]
    except KeyError:
        return None
    metadata = extractor(quality)
    meta_extract_error = True
    try:
        if 'scan_index' in kwargs:
            metadata.extract(parser, scan_index=kwargs['scan_index'])
        else:
            metadata.extract(parser)
        meta_extract_error = False
    except HACHOIR_ERRORS, err:
        error("Error during metadata extraction: %s" % unicode(err))
    except Exception, err:
        error("Error during metadata extraction: %s" % unicode(err))

    if meta_extract_error:
        try:
            parser.stream._input.close()
        except:
            pass
        return None

    if metadata:
        metadata.mime_type = parser.mime_type
        metadata.endian = endian_name[parser.endian]
    return metadata
예제 #25
0
    sys.exit(1)
from hachoir_metadata import extractMetadata
from hachoir_metadata.metadata import extractors as metadata_extractors
def processFile(filename, quality=0.5):
    charset = getTerminalCharset()
    filename, real_filename = unicodeFilename(filename, charset), filename

    # Create parser
    try:
        tags = None
        parser = createParser(filename, real_filename=real_filename, tags=tags)
    except InputStreamError, err:
        error(unicode(err))
        return False
    if not parser:
        error(_("Unable to parse file: %s") % filename)
        return False

    # Extract metadata
    try:
        return extractMetadata(parser, quality)
    except HachoirError, err:
        error(unicode(err))
        parser.error(_("Hachoir can't extract metadata, but is able to parse: %s")
            % filename)

    return None


def print_exif(path):
    img = PIL.Image.open(path)