diff options
Diffstat (limited to 'pkg')
| -rw-r--r-- | pkg/wince/wince-cab.cfg | 25 | ||||
| -rwxr-xr-x | pkg/wince/wince-cabgen | 653 |
2 files changed, 678 insertions, 0 deletions
diff --git a/pkg/wince/wince-cab.cfg b/pkg/wince/wince-cab.cfg new file mode 100644 index 00000000..1fdabd09 --- /dev/null +++ b/pkg/wince/wince-cab.cfg @@ -0,0 +1,25 @@ + +app_name = "Chocolate Doom" +provider = "Simon Howard" +arch = "strongarm" + +# Install files: + +d = "$(PROGRAMS_GAMES)/Chocolate Doom/" +s = "$(START_GAMES)/" + +files = { + d+"chocolate-doom.exe": "../../src/chocolate-doom.exe", + d+"chocolate-setup.exe": "../../setup/chocolate-setup.exe", + d+"SDL.dll": "SDL.dll", + d+"SDL_mixer.dll": "SDL_mixer.dll", + d+"SDL_net.dll": "SDL_net.dll", +} + +# Start menu links: + +links = { + s+"Chocolate Doom.lnk": d+"chocolate-doom.exe", + s+"Chocolate Doom Setup.lnk": d+"chocolate-setup.exe" +} + diff --git a/pkg/wince/wince-cabgen b/pkg/wince/wince-cabgen new file mode 100755 index 00000000..2b901f87 --- /dev/null +++ b/pkg/wince/wince-cabgen @@ -0,0 +1,653 @@ +#!/usr/bin/env python + +import os +import re +import shutil +import sys +import tempfile + +CAB_HEADER = "MSCE" + +ARCHITECTURES = { + "shx-sh3": 103, + "shx-sh4": 104, + "i386": 386, + "i486": 486, + "i586": 586, + "powerpc-601": 601, + "powerpc-603": 603, + "powerpc-604": 604, + "powerpc-620": 620, + "powerpc-mpc821": 821, + "arm720": 1824, + "arm820": 2080, + "arm920": 2336, + "strongarm": 2577, + "mips-r4000": 4000, + "sh3": 10003, + "sh3e": 10004, + "sh4": 10005, + "alpha-21064": 21064, + "arm7tdmi": 70001, +} + +DIR_VARIABLES = { + "PROGRAMS": "%CE1%", # \Program Files + "WINDOWS": "%CE2%", # \Windows + "DESKTOP": "%CE3%", # \Windows\Desktop + "STARTUP": "%CE4%", # \Windows\StartUp + "DOCUMENTS": "%CE5%", # \My Documents + "PROGRAMS_ACCESSORIES": "%CE6%", # \Program Files\Accessories + "PROGRAMS_COMMUNICATIONS": "%CE7%", # \Program Files\Communications + "PROGRAMS_GAMES": "%CE8%", # \Program Files\Games + "PROGRAMS_OUTLOOK": "%CE9%", # \Program Files\Pocket Outlook + "PROGRAMS_OFFICE": "%CE10%", # \Program Files\Office + "WINDOWS_PROGRAMS": "%CE11%", # \Windows\Programs + "WINDOWS_ACCESSORIES": "%CE12%", # \Windows\Programs\Accessories + "WINDOWS_COMMUNICATIONS": "%CE13%", # \Windows\Programs\Communications + "WINDOWS_GAMES": "%CE14%", # \Windows\Programs\Games + "FONTS": "%CE15%", # \Windows\Fonts + "RECENT": "%CE16%", # \Windows\Recent + "FAVORITES": "%CE17%", # \Windows\Favorites + + "START_PROGRAMS": "%CE11%", # \Windows\Start Menu\Programs + "START_ACCESSORIES": "%CE12%", # \Windows\Start Menu\Accessories + "START_COMMUNICATIONS": "%CE13%", # \Windows\Start Menu\Communications + "START_GAMES": "%CE14%", # \Windows\Start Menu\Games + "START": "%CE17%", # \Windows\Start Menu +} + +def write_int16(f, value): + b1 = value & 0xff + b2 = (value >> 8) & 0xff + f.write("%c%c" % (b1, b2)) + +def write_int32(f, value): + b1 = value & 0xff + b2 = (value >> 8) & 0xff + b3 = (value >> 16) & 0xff + b4 = (value >> 24) & 0xff + f.write("%c%c%c%c" % (b1, b2, b3, b4)) + +# Pad a string with NUL characters so that it has a length that is +# a multiple of 4. At least one NUL is always added. + +def pad_string(s): + pad_len = 4 - (len(s) % 4) + return s + (pad_len * "\x00") + +class HeaderSection: + + def __init__(self, cab_header): + self.cab_header = cab_header + self.arch = None + self.app_name = None + self.provider = None + self.unsupported = None + + def __len__(self): + return 100 # header has fixed size + + def set_meta(self, arch, app_name, provider, unsupported): + + if arch not in ARCHITECTURES: + raise Exception("Unknown architecture '%s'" % arch) + + self.arch = ARCHITECTURES[arch] + + dictionary = self.cab_header.dictionary + + self.app_name = app_name + dictionary.get(self.app_name) + + self.provider = provider + dictionary.get(self.provider) + + self.unsupported = unsupported + dictionary.get(self.unsupported) + + def write(self, stream): + + # Basic header + + stream.write(CAB_HEADER) + write_int32(stream, 0) + write_int32(stream, len(self.cab_header)) + write_int32(stream, 0) + write_int32(stream, 1) + write_int32(stream, self.arch) + + # minimum Windows CE version: + write_int32(stream, 0) + write_int32(stream, 0) + write_int32(stream, 0) + write_int32(stream, 0) + write_int32(stream, 0) + write_int32(stream, 0) + + dictionary = self.cab_header.dictionary + + # Write number of entries in other sections: + + for section in self.cab_header.sections: + if section is not self: + write_int16(stream, section.num_entries()) + + # Write offsets of other sections: + + for section in self.cab_header.sections: + if section is not self: + offset = self.cab_header.get_section_offset(section) + write_int32(stream, offset) + + # Special strings: + + special_strings = ( + self.app_name, + self.provider, + self.unsupported + ) + + dictionary_offset = self.cab_header.get_section_offset(dictionary) + + for s in special_strings: + s_offset = dictionary.get_offset(s) + write_int16(stream, dictionary_offset + s_offset) + write_int16(stream, len(s) + 1) + + # Two left-over fields of unknown use: + + write_int16(stream, 0) + write_int16(stream, 0) + +class StringDictionary: + def __init__(self, cab_header): + self.cab_header = cab_header + self.string_list = [] + self.strings = {} + self.length = 0 + self.index = 1 + + # Get the length of the dictionary, in bytes. + + def __len__(self): + return self.length + + # Get the number of entries in the dictionary. + + def num_entries(self): + return len(self.strings) + + # Get the ID for the given string, adding it if necessary. + + def get(self, s): + # Is this a new string? Add it to the dictionary. + + if s not in self.strings: + offset = self.length + padded = pad_string(s) + + self.strings[s] = (self.index, offset) + self.string_list.append((self.index, padded)) + self.length += len(padded) + 4 + self.index += 1 + + return self.strings[s][0] + + # Get the offset of a particular string within the dictionary. + + def get_offset(self, s): + return self.strings[s][1] + 4 + + # Write the dictionary to the output stream. + + def write(self, stream): + + # Write out all strings: + + for i, s in self.string_list: + write_int16(stream, i) + write_int16(stream, len(s)) + stream.write(s) + +class DirectoryList: + def __init__(self, cab_header): + self.cab_header = cab_header + self.directories_list = [] + self.directories = {} + self.length = 0 + self.index = 1 + + def __len__(self): + return self.length + + def num_entries(self): + return len(self.directories_list) + + # Find whether the specified directory exists in the list + + def find(self, dir): + key = dir.lower() + + if key in self.directories: + return self.directories[key] + else: + return None + + # Get the ID for the given directory, adding it if necessary. + + def get(self, dir): + + key = dir.lower() + dictionary = self.cab_header.dictionary + + # Add new directory? + + if key not in self.directories: + + # Separate into individual directories, and map to strings: + + #dir_path = dir.split("\\") + #if dir_path[0] == "": + # dir_path = dir_path[1:] + dir_path = [ dir ] + + dir_path = map(lambda x: dictionary.get(x), dir_path) + + self.directories[key] = self.index + self.directories_list.append((self.index, dir_path)) + self.length += 6 + 2 * len(dir_path) + self.index += 1 + + return self.directories[key] + + # Write the directory list to the specified stream. + + def write(self, stream): + for i, dir in self.directories_list: + write_int16(stream, i) + write_int16(stream, 2 * len(dir) + 2) + + for subdir in dir: + write_int16(stream, subdir) + + write_int16(stream, 0) + +class FileList: + def __init__(self, cab_header): + self.cab_header = cab_header + self.files = [] + self.length = 0 + self.index = 1 + + # Get the length of this section, in bytes. + + def __len__(self): + return self.length + + # Query whether the file list contains a particular file. + + def find(self, filename): + dirname, sep, target_basename = filename.rpartition("\\") + + target_basename = pad_string(target_basename) + + target_dir_id = self.cab_header.directory_list.find(dirname) + + if target_dir_id is None: + return None + else: + # Search the list of files: + + for i, dir_id, basename, file_no, flags in self.files: + if dir_id == target_dir_id and basename == target_basename: + return file_no + else: + return None + + # Get the number of entries in the file list + + def num_entries(self): + return len(self.files) + + # Add a file to the list. + + def add(self, filename, file_no, flags=0): + + dirname, sep, basename = filename.rpartition("\\") + + dir_id = self.cab_header.directory_list.get(dirname) + + padded = pad_string(basename) + + self.files.append((self.index, dir_id, padded, file_no, flags)) + self.length += 12 + len(padded) + self.index += 1 + + # Write this section to the output stream. + + def write(self, stream): + + for i, dir_id, filename, file_no, flags in self.files: + write_int16(stream, i) + write_int16(stream, dir_id) + write_int16(stream, file_no) + write_int32(stream, flags) + write_int16(stream, len(filename)) + stream.write(filename) + +# TODO? + +class RegHiveList: + def __len__(self): + return 0 + + def num_entries(self): + return 0 + + def write(self, stream): + pass + +class RegKeyList(): + def __len__(self): + return 0 + + def num_entries(self): + return 0 + + def write(self, stream): + pass + +class LinkList: + def __init__(self, cab_header): + self.cab_header = cab_header + self.links = [] + self.length = 0 + self.index = 1 + + def __len__(self): + return self.length + + def num_entries(self): + return len(self.links) + + # Determine the target type (dir/file) and ID: + + def __find_target(self, target): + file_id = self.cab_header.file_list.find(target) + + if file_id is not None: + return 1, file_id + + dir_list = self.cab_header.get_section(DirectoryList) + dir_id = dir_list.find(target) + + if dir_id is not None: + return 0, dir_id + + raise Exception("Link target '%s' not found" % target) + + def add(self, target, destination): + + target_type, target_id = self.__find_target(target) + + dest_path = destination.split("\\") + + # Leading \: + + if dest_path[0] == "": + dest_path = dest_path[1:] + + # %CEn% to specify the install root is handled differently for + # links than it is for files/dirs. + + match = re.match(r"\%CE(\d+)\%", dest_path[0]) + + if match: + base_dir = int(match.group(1)) + dest_path = dest_path[1:] + else: + base_dir = 0 + + # Map dirs that make up the path to strings. + + dictionary = self.cab_header.dictionary + dest_path = map(lambda x: dictionary.get(x), dest_path) + + self.links.append((self.index, target_type, target_id, + base_dir, dest_path)) + self.index += 1 + self.length += 14 + 2 * len(dest_path) + + def write(self, stream): + + for i, target_type, target_id, base_dir, dest_path in self.links: + + write_int16(stream, i) + write_int16(stream, 0) + write_int16(stream, base_dir) + write_int16(stream, target_id) + write_int16(stream, target_type) + write_int16(stream, 2 * len(dest_path) + 2) + + for subdir in dest_path: + write_int16(stream, subdir) + + write_int16(stream, 0) + +class CabHeaderFile: + def __init__(self): + self.dictionary = StringDictionary(self) + self.directory_list = DirectoryList(self) + self.file_list = FileList(self) + + self.sections = [ + HeaderSection(self), + self.dictionary, + self.directory_list, + self.file_list, + RegHiveList(), + RegKeyList(), + LinkList(self) + ] + + def set_meta(self, *args): + header_section = self.get_section(HeaderSection) + header_section.set_meta(*args) + + def add_file(self, filename, file_no, flags=0): + files_section = self.get_section(FileList) + files_section.add(filename, file_no, flags) + + def add_link(self, target, destination): + links_section = self.get_section(LinkList) + links_section.add(target, destination) + + def get_section(self, section_class): + for section in self.sections: + if isinstance(section, section_class): + return section + else: + raise Exception("Can't find section of class %s" % section_class) + + def get_section_offset(self, section): + offset = 0 + + for s in self.sections: + if section is s: + return offset + offset += len(s) + else: + raise Exception("Section %s not found in list") + + def __len__(self): + result = 0 + for s in self.sections: + result += len(s) + return result + + def write(self, stream): + old_pos = 0 + for section in self.sections: + section.write(stream) + pos = stream.tell() + if pos != old_pos + len(section): + raise Exception("Section is %i bytes long, but %i written" % \ + (len(section), pos - old_pos)) + old_pos = pos + +class CabFile: + def __init__(self, config): + self.cab_header = CabHeaderFile() + + self.__process_meta(config) + self.__process_files(config["files"]) + + if "links" in config: + self.__process_links(config["links"]) + + # Metadata: + + def __process_meta(self, config): + arch = config.get("arch") or "strongarm" + app_name = config.get("app_name") + provider = config.get("provider") + unsupported = config.get("unsupported") or "" + + if app_name is None or provider is None: + raise Exception("Application name and provider must be specified") + + self.cab_header.set_meta(arch, app_name, provider, unsupported) + self.app_name = app_name + + # Get the shortened 8.3 filename used for the specified file + # within the CAB. + + def __shorten_name(self, filename, file_no): + + # Strip down to base filename without extension: + + basename = os.path.basename(filename) + + if "." in basename: + basename = basename.rpartition(".")[0] + + # Remove non-alphanumeric characters: + + def only_alnum(x): + if x.isalnum(): + return x + else: + return "" + + cleaned_name = "".join(map(only_alnum, basename)) + short_name = cleaned_name[0:8] + + if len(short_name) < 8: + short_name = "0" * (8 - len(short_name)) + short_name + + return "%s.%03i" % (short_name, file_no) + + # Process the list of files to install: + + def __process_files(self, files): + self.files = [ self.app_name ] + + for filename, source_file in files.items(): + file_no = len(self.files) + filename = expand_path(filename) + self.cab_header.add_file(filename, file_no) + self.files.append(source_file) + + # Process the list of links: + + def __process_links(self, links): + for destination, target in links.items(): + target = expand_path(target) + destination = expand_path(destination) + self.cab_header.add_link(target, destination) + + # Write the header file: + + def __write_header(self, dir): + + basename = self.__shorten_name(self.files[0], 0) + filename = os.path.join(dir, basename) + + stream = file(filename, "w") + self.cab_header.write(stream) + stream.close() + + return [ filename ] + + # Write the files: + + def __write_files(self, dir): + + result = [] + + for file_no in range(1, len(self.files)): + source_file = self.files[file_no] + basename = self.__shorten_name(source_file, file_no) + filename = os.path.join(dir, basename) + + shutil.copy(source_file, filename) + result.append(filename) + + return result + + # Output to a file: + + def write(self, filename): + + temp_dir = tempfile.mkdtemp() + + header = self.__write_header(temp_dir) + files = self.__write_files(temp_dir) + files.reverse() + + args = [ "lcab", "-n" ] + header + files + [ filename ] + + os.spawnlp(os.P_WAIT, "lcab", *args) + +def expand_path(filename): + + # Replace Unix-style / path separators with DOS-style \ + + filename = filename.replace("/", "\\") + + # Expand $(xyz) path variables to their Windows equivalents: + + def replace_var(match): + var_name = match.group(1) + + if not var_name in DIR_VARIABLES: + raise Exception("Unknown variable '%s'" % var_name) + else: + return DIR_VARIABLES[var_name] + + return re.sub(r"\$\((.*?)\)", replace_var, filename) + +def read_config_file(filename): + f = file(filename) + + data = f.readlines() + data = "".join(data) + + f.close() + + prog = compile(data, filename, "exec") + result = {} + eval(prog, result) + + return result + +if len(sys.argv) < 3: + print "Usage: %s <config file> <output file>" % sys.argv[0] + sys.exit(0) + +config = read_config_file(sys.argv[1]) + +cab_file = CabFile(config) +cab_file.write(sys.argv[2]) + |