def searchFile(self, filename, pattern, case_sensitive=True):
self.filename = filename
self.case_sensitive = case_sensitive
if pattern and not self.case_sensitive:
pattern = pattern.lower()
self.pattern = pattern
try:
self.parser = createParser(self.filename)
except InputStreamError as err:
error("Unable to open file: %s" % err)
sys.exit(1)
if not self.parser:
error("Unable to parse file: %s" % self.filename)
sys.exit(1)
with self.parser:
try:
self.grep(self.parser)
except IOError as err:
if err[0] == errno.EPIPE:
# Ignore broken PIPE error
return
else:
raise
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 Exception as err:
error("Error during metadata extraction: %s" % unicode(err))
if meta_extract_error:
try:
parser.stream._input.close()
except (StandardError, Exception):
pass
return None
if metadata:
metadata.mime_type = parser.mime_type
metadata.endian = endian_name[parser.endian]
return metadata
def __call__(self, prev):
name = self.path + "[]"
address, size, last = next(self.cluster)
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:
def next():
return self(field)
field.setLinks(prev.first, next)
self.root.writeFieldsIn(padding, address, (field, ))
return field
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 Exception as err:
error("Error during metadata extraction: %s" % unicode(err))
if meta_extract_error:
try:
parser.stream._input.close()
except (StandardError, Exception):
pass
return None
if metadata:
metadata.mime_type = parser.mime_type
metadata.endian = endian_name[parser.endian]
return metadata
def _getContentSize(self):
if not hasattr(self, "_content_size"):
try:
self._content_size = self.createContentSize()
except Exception as err:
error("Unable to compute %s content size: %s" % (self.__class__.__name__, err))
self._content_size = None
return self._content_size
def _getContentSize(self):
if not hasattr(self, "_content_size"):
try:
self._content_size = self.createContentSize()
except Exception as err:
error("Unable to compute %s content size: %s" % (self.__class__.__name__, err))
self._content_size = None
return self._content_size
def _getDescription(self):
if self._description is None:
try:
self._description = self.createDescription()
if isinstance(self._description, str):
self._description = makeUnicode(self._description)
except Exception as err:
error("Error getting description of %s: %s"
% (self.path, str(err)))
self._description = self.PARSER_TAGS["description"]
return self._description
def _getDescription(self):
if self._description is None:
try:
self._description = self.createDescription()
if isinstance(self._description, str):
self._description = makeUnicode(self._description)
except Exception as err:
error("Error getting description of %s: %s" \
% (self.path, unicode(err)))
self._description = self.PARSER_TAGS["description"]
return self._description
def _getMimeType(self):
if not self._mime_type:
try:
self._mime_type = self.createMimeType()
except Exception as err:
error("Error when creating MIME type: %s" % unicode(err))
if not self._mime_type \
and self.createMimeType != Parser.createMimeType:
self._mime_type = Parser.createMimeType(self)
if not self._mime_type:
self._mime_type = u"application/octet-stream"
return self._mime_type
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 = path.join(self.directory, filename)
output = FileOutputStream(filename)
# Write output
try:
output.copyBytesFrom(stream, offset, size // 8)
except StreamError as err:
error("copyBytesFrom() error: %s" % err)
return filename
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 Exception as err:
error("Error during metadata extraction: %s" % str(err))
if metadata:
metadata.mime_type = parser.mime_type
metadata.endian = endian_name[parser.endian]
return metadata
def test_random_stream(self, tests=(1, 8)):
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 range((n - 1) // k + 1):
a.append(random.getrandbits(k))
a = StringInputStream(a.tobytes(), source="<random data>")
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
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)
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)
def processFile(values,
filename,
display_filename=False,
priority=None,
human=True,
display=True):
charset = getTerminalCharset()
# Create parser
try:
if values.force_parser:
tags = [("id", values.force_parser), None]
else:
tags = None
parser = createParser(filename, tags=tags)
except InputStreamError as err:
error(str(err))
return False
if not parser:
error("Unable to parse file: %s" % filename)
return False
with parser:
# Extract metadata
extract_metadata = not (values.mime or values.type)
if extract_metadata:
try:
metadata = extractMetadata(parser, values.quality)
except Exception as err:
error(str(err))
metadata = None
if not metadata:
parser.error(
"Hachoir can't extract metadata, but is able to parse: %s"
% filename)
return False
else:
if values.type:
result = parser.description
else:
result = parser.mime_type
if hasattr(config, 'RESULT_DICTS'):
# Append a python Dictionary, to be used within pyhton
if extract_metadata:
dict_ = metadata.exportDictionary(priority=priority, human=human)
if not dict_:
dict_ = {"message": "(no metadata, priority may be too small)"}
if display_filename:
dict_.setdefault("file path", filename)
else:
if values.type:
dict_ = {('type' if values.raw else 'Type'): result}
else:
dict_ = {('mime_type' if values.raw else 'MIME type'): result}
if display_filename:
dict_.setdefault("file path", filename)
config.RESULT_DICTS.append(dict_)
if display:
# Display metadatas on stdout
if extract_metadata:
text = metadata.exportPlaintext(priority=priority, human=human)
if not text:
text = ["(no metadata, priority may be too small)"]
if display_filename:
for line in text:
line = "%s: %s" % (filename, line)
print(makePrintable(line, charset))
else:
for line in text:
print(makePrintable(line, charset))
else:
text = result
if display_filename:
text = "%s: %s" % (filename, text)
print(text)
return True
def processFile(values,
filename,
display_filename=False,
priority=None,
human=True,
display=True):
charset = getTerminalCharset()
# Create parser
try:
if values.force_parser:
tags = [("id", values.force_parser), None]
else:
tags = None
parser = createParser(filename, tags=tags)
except InputStreamError as err:
error(str(err))
return False
if not parser:
error("Unable to parse file: %s" % filename)
return False
with parser:
# Extract metadata
extract_metadata = not (values.mime or values.type)
if extract_metadata:
try:
metadata = extractMetadata(parser, values.quality)
except Exception as err:
error(str(err))
metadata = None
if not metadata:
parser.error(
"Hachoir can't extract metadata, but is able to parse: %s"
% filename)
return False
else:
if values.type:
result = parser.description
else:
result = parser.mime_type
if display:
# Display metadatas on stdout
if extract_metadata:
text = metadata.exportPlaintext(priority=priority, human=human)
if not text:
text = ["(no metadata, priority may be too small)"]
if display_filename:
for line in text:
line = "%s: %s" % (filename, line)
print(makePrintable(line, charset))
else:
for line in text:
print(makePrintable(line, charset))
else:
text = result
if display_filename:
text = "%s: %s" % (filename, text)
print(text)
return True
