Subversion Repositories programming

"""Simple Par2 parsing class

This program is part of rarslave, an open-source program for

automatically checking, repairing, and extracting files, primarily

those which are downloaded from usenet.

Visit https://svn.irasnyder.com/svn/programming/rarslave for the

latest version.

"""

__author__ = "Ira W. Snyder (devel@irasnyder.com)"

__copyright__ = "Copyright (c) 2005,2006 Ira W. Snyder (devel@irasnyder.com)"

__license__ = "GNU GPL v2 (or, at your option, any later version"

	def __init__ (self, par2_filename):

		"""Constructor for the Par2Parser class.

		   This will automatically perform all of the parsing and finding

		   values for the entire class. This makes this class slow, so try

		   not to re-construct it too many times."""

		self.__par2_filename = par2_filename

		self.__good_par2_files = []

		self.__corrupt_par2_files = []

		self.__protected_files = []

		self.__possible_files = []

		self.__set_basename = ''

		self.__escaped_basename = ''

		self.__main_logic ()

	def get_par2_filename (self):

		"""Get the main Par2 filename."""

		return self.__par2_filename

	def get_good_par2_files (self):

		"""Get a list of good Par2 files in this set."""

		return self.__good_par2_files

	def get_corrupt_par2_files (self):

		"""Get a list of corrupt Par2 files in this set."""

		return self.__corrupt_par2_files

	def get_protected_files (self):

		"""Get a list of filenames protected by the Par2 set."""

		return self.__protected_files

	def get_possible_files (self):

		"""Get a list of files that have a name similar to the main

		   Par2 filename."""

		return self.__possible_files

	def get_set_basename (self):

		"""Get the base filename of the Par2 set.

		   The base filename is the Par2 filename given, minus the

		   first filename extension.

		   Example: For "test.par2", the base filename would be "test"."""

		return self.__set_basename

	def get_escaped_basename (self):

		"""Get the escaped base filename of the Par2 set.

		   This name is suitable for use in regular expressions where

		   you just want to match using the literal base name."""

		return self.__escaped_basename

	def __main_logic (self):

		"""Fills in all of the private variables in the class.

		   This should be called before you use any of the getter

		   methods in the class."""

		####################################################

		# 1. Find out if we're parsing a "vol" file or not

		####################################################

		# Get the base filename of self.par2_filename

		if (re.search ('\.vol\d+\+\d+\.par2$', self.__par2_filename, re.IGNORECASE)):

			self.__set_basename = os.path.splitext (self.__par2_filename)[0]

			self.__set_basename = os.path.splitext (self.__set_basename)[0]

		else:

			self.__set_basename = os.path.splitext (self.__par2_filename)[0]

		####################################################

		# 2. re.escape the filename

		####################################################

		self.__escaped_basename = re.escape (self.__set_basename)

		####################################################

		# 3. use the escaped filename to find all other files in the current set

		#    a. should be good for .000, .001, .r00, .rar

		#    b. should also find all par2 files

		####################################################

		regex = re.compile ('^%s' % (self.__escaped_basename, ))

		self.__possible_files = [f for f in os.listdir(os.getcwd()) if regex.match (f)]

		####################################################

		# 4. Parse all par2 files

		#    a. add to the good_par2_files list if it is good

		#    b. add to the corrupt_par2_files list if it is corrupt

		####################################################

		regex = re.compile ('\.par2$', re.IGNORECASE)

		for f in self.__possible_files:

			if regex.search (f):

				# Try to parse the par2 file

				try:

					filenames = self.__parse_par2_file (f)

					self.__good_par2_files.append (f)

				except:

					self.__corrupt_par2_files.append (f)

		####################################################

		# 5. Parse good_par2_files[0], if it exists

		#    a. if it doesn't exist, we can't really parse any of them

		#       so return what we've got

		####################################################

		if len(self.__good_par2_files) > 0:

			self.__good_par2_files.sort()

			f = self.__good_par2_files[0]

			self.__par2_filename = self.__good_par2_files[0]

			self.__protected_files = self.__parse_par2_file (f)

	def __chompnulls (self, line):

		"""Returns the line up to the first null character"""

		p = line.find('\0')

		if p < 0:

			return line

		else:

			return line[:p]

	def __parse_par2_file (self, filename):

		"""Get all of the filenames that are protected by the par2

		file given as the filename"""

		try:

			file = open(filename, 'rb')

		except:

			print 'Could not open %s' % (filename, )

			return []

		# We always want to do crc checks

		docrcchecks = True

		pkt_header_fmt = '< 8s Q 16s 16s 16s'

		pkt_header_size = struct.calcsize(pkt_header_fmt)

		file_pkt_fmt = '< 16s 16s 16s Q'

		file_pkt_size = struct.calcsize(file_pkt_fmt)

		main_pkt_fmt = '< Q I'

		main_pkt_size = struct.calcsize(main_pkt_fmt)

		seen_file_ids = {}

		expected_file_ids = None

		filenames = []

		while 1:

			d = file.read(pkt_header_size)

			if not d:

				break

			magic, pkt_len, pkt_md5, set_id, pkt_type = struct.unpack(pkt_header_fmt, d)

			if docrcchecks:

				import md5

				control_md5 = md5.new()

				control_md5.update(d[0x20:])

				d = file.read(pkt_len - pkt_header_size)

				control_md5.update(d)

				if control_md5.digest() != pkt_md5:

					raise EnvironmentError, (errno.EINVAL, \

						"corrupt par2 file - bad packet hash")

			if pkt_type == 'PAR 2.0\0FileDesc':

				if not docrcchecks:

					d = file.read(pkt_len - pkt_header_size)

				file_id, file_md5, file_md5_16k, file_size = \

					struct.unpack(file_pkt_fmt, d[:file_pkt_size])

				if seen_file_ids.get(file_id) is None:

					seen_file_ids[file_id] = 1

					filename = self.__chompnulls(d[file_pkt_size:])

					filenames.append(filename)

			elif pkt_type == "PAR 2.0\0Main\0\0\0\0":

				if not docrcchecks:

					d = file.read(pkt_len - pkt_header_size)

				if expected_file_ids is None:

					expected_file_ids = []

					slice_size, num_files = struct.unpack(main_pkt_fmt, d[:main_pkt_size])

					num_nonrecovery = (len(d)-main_pkt_size)/16 - num_files

					for i in range(main_pkt_size,main_pkt_size+(num_files+num_nonrecovery)*16,16):

						expected_file_ids.append(d[i:i+16])

			else:

				if not docrcchecks:

					file.seek(pkt_len - pkt_header_size, 1)

		if expected_file_ids is None:

			raise EnvironmentError, (errno.EINVAL, \

				"corrupt or unsupported par2 file - no main packet found")

		for id in expected_file_ids:

			if not seen_file_ids.has_key(id):

				raise EnvironmentError, (errno.EINVAL, \

					"corrupt or unsupported par2 file - " \

					"expected file description packet not found")

	while not os.path.isfile (fname):

		print "not a file, try again!"

		fname = raw_input ("Enter PAR2 Filename to test: ")

		fname = os.path.abspath (os.path.expanduser (fname))

	os.chdir(os.path.dirname(fname))

	fname = os.path.basename (fname)

	p = Par2Parser (fname)