ref: a2c0e55e6885fde0d135831a77d227bc933d89e7
dir: /sys/src/cmd/python/Tools/msi/msilib.py/
# Microsoft Installer Library # (C) 2003 Martin v. Loewis import win32com.client.gencache import win32com.client import pythoncom, pywintypes from win32com.client import constants import re, string, os, sets, glob, popen2, sys, _winreg, struct try: basestring except NameError: basestring = (str, unicode) # Partially taken from Wine datasizemask= 0x00ff type_valid= 0x0100 type_localizable= 0x0200 typemask= 0x0c00 type_long= 0x0000 type_short= 0x0400 type_string= 0x0c00 type_binary= 0x0800 type_nullable= 0x1000 type_key= 0x2000 # XXX temporary, localizable? knownbits = datasizemask | type_valid | type_localizable | \ typemask | type_nullable | type_key # Summary Info Property IDs PID_CODEPAGE=1 PID_TITLE=2 PID_SUBJECT=3 PID_AUTHOR=4 PID_KEYWORDS=5 PID_COMMENTS=6 PID_TEMPLATE=7 PID_LASTAUTHOR=8 PID_REVNUMBER=9 PID_LASTPRINTED=11 PID_CREATE_DTM=12 PID_LASTSAVE_DTM=13 PID_PAGECOUNT=14 PID_WORDCOUNT=15 PID_CHARCOUNT=16 PID_APPNAME=18 PID_SECURITY=19 def reset(): global _directories _directories = sets.Set() def EnsureMSI(): win32com.client.gencache.EnsureModule('{000C1092-0000-0000-C000-000000000046}', 1033, 1, 0) def EnsureMSM(): try: win32com.client.gencache.EnsureModule('{0ADDA82F-2C26-11D2-AD65-00A0C9AF11A6}', 0, 1, 0) except pywintypes.com_error: win32com.client.gencache.EnsureModule('{0ADDA82F-2C26-11D2-AD65-00A0C9AF11A6}', 0, 2, 0) _Installer=None def MakeInstaller(): global _Installer if _Installer is None: EnsureMSI() _Installer = win32com.client.Dispatch('WindowsInstaller.Installer', resultCLSID='{000C1090-0000-0000-C000-000000000046}') return _Installer _Merge=None def MakeMerge2(): global _Merge if _Merge is None: EnsureMSM() _Merge = win32com.client.Dispatch("Msm.Merge2.1") return _Merge class Table: def __init__(self, name): self.name = name self.fields = [] def add_field(self, index, name, type): self.fields.append((index,name,type)) def sql(self): fields = [] keys = [] self.fields.sort() fields = [None]*len(self.fields) for index, name, type in self.fields: index -= 1 unk = type & ~knownbits if unk: print "%s.%s unknown bits %x" % (self.name, name, unk) size = type & datasizemask dtype = type & typemask if dtype == type_string: if size: tname="CHAR(%d)" % size else: tname="CHAR" elif dtype == type_short: assert size==2 tname = "SHORT" elif dtype == type_long: assert size==4 tname="LONG" elif dtype == type_binary: assert size==0 tname="OBJECT" else: tname="unknown" print "%s.%sunknown integer type %d" % (self.name, name, size) if type & type_nullable: flags = "" else: flags = " NOT NULL" if type & type_localizable: flags += " LOCALIZABLE" fields[index] = "`%s` %s%s" % (name, tname, flags) if type & type_key: keys.append("`%s`" % name) fields = ", ".join(fields) keys = ", ".join(keys) return "CREATE TABLE %s (%s PRIMARY KEY %s)" % (self.name, fields, keys) def create(self, db): v = db.OpenView(self.sql()) v.Execute(None) v.Close() class Binary: def __init__(self, fname): self.name = fname def __repr__(self): return 'msilib.Binary(os.path.join(dirname,"%s"))' % self.name def gen_schema(destpath, schemapath): d = MakeInstaller() schema = d.OpenDatabase(schemapath, win32com.client.constants.msiOpenDatabaseModeReadOnly) # XXX ORBER BY v=schema.OpenView("SELECT * FROM _Columns") curtable=None tables = [] v.Execute(None) f = open(destpath, "wt") f.write("from msilib import Table\n") while 1: r=v.Fetch() if not r:break name=r.StringData(1) if curtable != name: f.write("\n%s = Table('%s')\n" % (name,name)) curtable = name tables.append(name) f.write("%s.add_field(%d,'%s',%d)\n" % (name, r.IntegerData(2), r.StringData(3), r.IntegerData(4))) v.Close() f.write("\ntables=[%s]\n\n" % (", ".join(tables))) # Fill the _Validation table f.write("_Validation_records = [\n") v = schema.OpenView("SELECT * FROM _Validation") v.Execute(None) while 1: r = v.Fetch() if not r:break # Table, Column, Nullable f.write("(%s,%s,%s," % (`r.StringData(1)`, `r.StringData(2)`, `r.StringData(3)`)) def put_int(i): if r.IsNull(i):f.write("None, ") else:f.write("%d," % r.IntegerData(i)) def put_str(i): if r.IsNull(i):f.write("None, ") else:f.write("%s," % `r.StringData(i)`) put_int(4) # MinValue put_int(5) # MaxValue put_str(6) # KeyTable put_int(7) # KeyColumn put_str(8) # Category put_str(9) # Set put_str(10)# Description f.write("),\n") f.write("]\n\n") f.close() def gen_sequence(destpath, msipath): dir = os.path.dirname(destpath) d = MakeInstaller() seqmsi = d.OpenDatabase(msipath, win32com.client.constants.msiOpenDatabaseModeReadOnly) v = seqmsi.OpenView("SELECT * FROM _Tables"); v.Execute(None) f = open(destpath, "w") print >>f, "import msilib,os;dirname=os.path.dirname(__file__)" tables = [] while 1: r = v.Fetch() if not r:break table = r.StringData(1) tables.append(table) f.write("%s = [\n" % table) v1 = seqmsi.OpenView("SELECT * FROM `%s`" % table) v1.Execute(None) info = v1.ColumnInfo(constants.msiColumnInfoTypes) while 1: r = v1.Fetch() if not r:break rec = [] for i in range(1,r.FieldCount+1): if r.IsNull(i): rec.append(None) elif info.StringData(i)[0] in "iI": rec.append(r.IntegerData(i)) elif info.StringData(i)[0] in "slSL": rec.append(r.StringData(i)) elif info.StringData(i)[0]=="v": size = r.DataSize(i) bytes = r.ReadStream(i, size, constants.msiReadStreamBytes) bytes = bytes.encode("latin-1") # binary data represented "as-is" if table == "Binary": fname = rec[0]+".bin" open(os.path.join(dir,fname),"wb").write(bytes) rec.append(Binary(fname)) else: rec.append(bytes) else: raise "Unsupported column type", info.StringData(i) f.write(repr(tuple(rec))+",\n") v1.Close() f.write("]\n\n") v.Close() f.write("tables=%s\n" % repr(map(str,tables))) f.close() class _Unspecified:pass def change_sequence(seq, action, seqno=_Unspecified, cond = _Unspecified): "Change the sequence number of an action in a sequence list" for i in range(len(seq)): if seq[i][0] == action: if cond is _Unspecified: cond = seq[i][1] if seqno is _Unspecified: seqno = seq[i][2] seq[i] = (action, cond, seqno) return raise ValueError, "Action not found in sequence" def add_data(db, table, values): d = MakeInstaller() v = db.OpenView("SELECT * FROM `%s`" % table) count = v.ColumnInfo(0).FieldCount r = d.CreateRecord(count) for value in values: assert len(value) == count, value for i in range(count): field = value[i] if isinstance(field, (int, long)): r.SetIntegerData(i+1,field) elif isinstance(field, basestring): r.SetStringData(i+1,field) elif field is None: pass elif isinstance(field, Binary): r.SetStream(i+1, field.name) else: raise TypeError, "Unsupported type %s" % field.__class__.__name__ v.Modify(win32com.client.constants.msiViewModifyInsert, r) r.ClearData() v.Close() def add_stream(db, name, path): d = MakeInstaller() v = db.OpenView("INSERT INTO _Streams (Name, Data) VALUES ('%s', ?)" % name) r = d.CreateRecord(1) r.SetStream(1, path) v.Execute(r) v.Close() def init_database(name, schema, ProductName, ProductCode, ProductVersion, Manufacturer): try: os.unlink(name) except OSError: pass ProductCode = ProductCode.upper() d = MakeInstaller() # Create the database db = d.OpenDatabase(name, win32com.client.constants.msiOpenDatabaseModeCreate) # Create the tables for t in schema.tables: t.create(db) # Fill the validation table add_data(db, "_Validation", schema._Validation_records) # Initialize the summary information, allowing atmost 20 properties si = db.GetSummaryInformation(20) si.SetProperty(PID_TITLE, "Installation Database") si.SetProperty(PID_SUBJECT, ProductName) si.SetProperty(PID_AUTHOR, Manufacturer) si.SetProperty(PID_TEMPLATE, msi_type) si.SetProperty(PID_REVNUMBER, gen_uuid()) si.SetProperty(PID_WORDCOUNT, 2) # long file names, compressed, original media si.SetProperty(PID_PAGECOUNT, 200) si.SetProperty(PID_APPNAME, "Python MSI Library") # XXX more properties si.Persist() add_data(db, "Property", [ ("ProductName", ProductName), ("ProductCode", ProductCode), ("ProductVersion", ProductVersion), ("Manufacturer", Manufacturer), ("ProductLanguage", "1033")]) db.Commit() return db def add_tables(db, module): for table in module.tables: add_data(db, table, getattr(module, table)) def make_id(str): #str = str.replace(".", "_") # colons are allowed str = str.replace(" ", "_") str = str.replace("-", "_") if str[0] in string.digits: str = "_"+str assert re.match("^[A-Za-z_][A-Za-z0-9_.]*$", str), "FILE"+str return str def gen_uuid(): return str(pythoncom.CreateGuid()) class CAB: def __init__(self, name): self.name = name self.file = open(name+".txt", "wt") self.filenames = sets.Set() self.index = 0 def gen_id(self, dir, file): logical = _logical = make_id(file) pos = 1 while logical in self.filenames: logical = "%s.%d" % (_logical, pos) pos += 1 self.filenames.add(logical) return logical def append(self, full, file, logical = None): if os.path.isdir(full): return if not logical: logical = self.gen_id(dir, file) self.index += 1 if full.find(" ")!=-1: print >>self.file, '"%s" %s' % (full, logical) else: print >>self.file, '%s %s' % (full, logical) return self.index, logical def commit(self, db): self.file.close() try: os.unlink(self.name+".cab") except OSError: pass for k, v in [(r"Software\Microsoft\VisualStudio\7.1\Setup\VS", "VS7CommonBinDir"), (r"Software\Microsoft\Win32SDK\Directories", "Install Dir")]: try: key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, k) except WindowsError: continue cabarc = os.path.join(_winreg.QueryValueEx(key, v)[0], r"Bin", "cabarc.exe") _winreg.CloseKey(key) if not os.path.exists(cabarc):continue break else: print "WARNING: cabarc.exe not found in registry" cabarc = "cabarc.exe" f = popen2.popen4(r'"%s" -m lzx:21 n %s.cab @%s.txt' % (cabarc, self.name, self.name))[0] for line in f: if line.startswith(" -- adding "): sys.stdout.write(".") else: sys.stdout.write(line) sys.stdout.flush() if not os.path.exists(self.name+".cab"): raise IOError, "cabarc failed" add_data(db, "Media", [(1, self.index, None, "#"+self.name, None, None)]) add_stream(db, self.name, self.name+".cab") os.unlink(self.name+".txt") os.unlink(self.name+".cab") db.Commit() _directories = sets.Set() class Directory: def __init__(self, db, cab, basedir, physical, _logical, default, componentflags=None): """Create a new directory in the Directory table. There is a current component at each point in time for the directory, which is either explicitly created through start_component, or implicitly when files are added for the first time. Files are added into the current component, and into the cab file. To create a directory, a base directory object needs to be specified (can be None), the path to the physical directory, and a logical directory name. Default specifies the DefaultDir slot in the directory table. componentflags specifies the default flags that new components get.""" index = 1 _logical = make_id(_logical) logical = _logical while logical in _directories: logical = "%s%d" % (_logical, index) index += 1 _directories.add(logical) self.db = db self.cab = cab self.basedir = basedir self.physical = physical self.logical = logical self.component = None self.short_names = sets.Set() self.ids = sets.Set() self.keyfiles = {} self.componentflags = componentflags if basedir: self.absolute = os.path.join(basedir.absolute, physical) blogical = basedir.logical else: self.absolute = physical blogical = None add_data(db, "Directory", [(logical, blogical, default)]) def start_component(self, component = None, feature = None, flags = None, keyfile = None, uuid=None): """Add an entry to the Component table, and make this component the current for this directory. If no component name is given, the directory name is used. If no feature is given, the current feature is used. If no flags are given, the directory's default flags are used. If no keyfile is given, the KeyPath is left null in the Component table.""" if flags is None: flags = self.componentflags if uuid is None: uuid = gen_uuid() else: uuid = uuid.upper() if component is None: component = self.logical self.component = component if Win64: flags |= 256 if keyfile: keyid = self.cab.gen_id(self.absolute, keyfile) self.keyfiles[keyfile] = keyid else: keyid = None add_data(self.db, "Component", [(component, uuid, self.logical, flags, None, keyid)]) if feature is None: feature = current_feature add_data(self.db, "FeatureComponents", [(feature.id, component)]) def make_short(self, file): parts = file.split(".") if len(parts)>1: suffix = parts[-1].upper() else: suffix = None prefix = parts[0].upper() if len(prefix) <= 8 and (not suffix or len(suffix)<=3): if suffix: file = prefix+"."+suffix else: file = prefix assert file not in self.short_names else: prefix = prefix[:6] if suffix: suffix = suffix[:3] pos = 1 while 1: if suffix: file = "%s~%d.%s" % (prefix, pos, suffix) else: file = "%s~%d" % (prefix, pos) if file not in self.short_names: break pos += 1 assert pos < 10000 if pos in (10, 100, 1000): prefix = prefix[:-1] self.short_names.add(file) assert not re.search(r'[\?|><:/*"+,;=\[\]]', file) # restrictions on short names return file def add_file(self, file, src=None, version=None, language=None): """Add a file to the current component of the directory, starting a new one one if there is no current component. By default, the file name in the source and the file table will be identical. If the src file is specified, it is interpreted relative to the current directory. Optionally, a version and a language can be specified for the entry in the File table.""" if not self.component: self.start_component(self.logical, current_feature) if not src: # Allow relative paths for file if src is not specified src = file file = os.path.basename(file) absolute = os.path.join(self.absolute, src) assert not re.search(r'[\?|><:/*]"', file) # restrictions on long names if self.keyfiles.has_key(file): logical = self.keyfiles[file] else: logical = None sequence, logical = self.cab.append(absolute, file, logical) assert logical not in self.ids self.ids.add(logical) short = self.make_short(file) full = "%s|%s" % (short, file) filesize = os.stat(absolute).st_size # constants.msidbFileAttributesVital # Compressed omitted, since it is the database default # could add r/o, system, hidden attributes = 512 add_data(self.db, "File", [(logical, self.component, full, filesize, version, language, attributes, sequence)]) if not version: # Add hash if the file is not versioned filehash = MakeInstaller().FileHash(absolute, 0) add_data(self.db, "MsiFileHash", [(logical, 0, filehash.IntegerData(1), filehash.IntegerData(2), filehash.IntegerData(3), filehash.IntegerData(4))]) # Automatically remove .pyc/.pyo files on uninstall (2) # XXX: adding so many RemoveFile entries makes installer unbelievably # slow. So instead, we have to use wildcard remove entries # if file.endswith(".py"): # add_data(self.db, "RemoveFile", # [(logical+"c", self.component, "%sC|%sc" % (short, file), # self.logical, 2), # (logical+"o", self.component, "%sO|%so" % (short, file), # self.logical, 2)]) def glob(self, pattern, exclude = None): """Add a list of files to the current component as specified in the glob pattern. Individual files can be excluded in the exclude list.""" files = glob.glob1(self.absolute, pattern) for f in files: if exclude and f in exclude: continue self.add_file(f) return files def remove_pyc(self): "Remove .pyc/.pyo files on uninstall" add_data(self.db, "RemoveFile", [(self.component+"c", self.component, "*.pyc", self.logical, 2), (self.component+"o", self.component, "*.pyo", self.logical, 2)]) class Feature: def __init__(self, db, id, title, desc, display, level = 1, parent=None, directory = None, attributes=0): self.id = id if parent: parent = parent.id add_data(db, "Feature", [(id, parent, title, desc, display, level, directory, attributes)]) def set_current(self): global current_feature current_feature = self class Control: def __init__(self, dlg, name): self.dlg = dlg self.name = name def event(self, ev, arg, cond = "1", order = None): add_data(self.dlg.db, "ControlEvent", [(self.dlg.name, self.name, ev, arg, cond, order)]) def mapping(self, ev, attr): add_data(self.dlg.db, "EventMapping", [(self.dlg.name, self.name, ev, attr)]) def condition(self, action, condition): add_data(self.dlg.db, "ControlCondition", [(self.dlg.name, self.name, action, condition)]) class RadioButtonGroup(Control): def __init__(self, dlg, name, property): self.dlg = dlg self.name = name self.property = property self.index = 1 def add(self, name, x, y, w, h, text, value = None): if value is None: value = name add_data(self.dlg.db, "RadioButton", [(self.property, self.index, value, x, y, w, h, text, None)]) self.index += 1 class Dialog: def __init__(self, db, name, x, y, w, h, attr, title, first, default, cancel): self.db = db self.name = name self.x, self.y, self.w, self.h = x,y,w,h add_data(db, "Dialog", [(name, x,y,w,h,attr,title,first,default,cancel)]) def control(self, name, type, x, y, w, h, attr, prop, text, next, help): add_data(self.db, "Control", [(self.name, name, type, x, y, w, h, attr, prop, text, next, help)]) return Control(self, name) def text(self, name, x, y, w, h, attr, text): return self.control(name, "Text", x, y, w, h, attr, None, text, None, None) def bitmap(self, name, x, y, w, h, text): return self.control(name, "Bitmap", x, y, w, h, 1, None, text, None, None) def line(self, name, x, y, w, h): return self.control(name, "Line", x, y, w, h, 1, None, None, None, None) def pushbutton(self, name, x, y, w, h, attr, text, next): return self.control(name, "PushButton", x, y, w, h, attr, None, text, next, None) def radiogroup(self, name, x, y, w, h, attr, prop, text, next): add_data(self.db, "Control", [(self.name, name, "RadioButtonGroup", x, y, w, h, attr, prop, text, next, None)]) return RadioButtonGroup(self, name, prop) def checkbox(self, name, x, y, w, h, attr, prop, text, next): return self.control(name, "CheckBox", x, y, w, h, attr, prop, text, next, None) def pe_type(path): header = open(path, "rb").read(1000) # offset of PE header is at offset 0x3c pe_offset = struct.unpack("<i", header[0x3c:0x40])[0] assert header[pe_offset:pe_offset+4] == "PE\0\0" machine = struct.unpack("<H", header[pe_offset+4:pe_offset+6])[0] return machine def set_arch_from_file(path): global msi_type, Win64, arch_ext machine = pe_type(path) if machine == 0x14c: # i386 msi_type = "Intel" Win64 = 0 arch_ext = '' elif machine == 0x200: # Itanium msi_type = "Intel64" Win64 = 1 arch_ext = '.ia64' elif machine == 0x8664: # AMD64 msi_type = "x64" Win64 = 1 arch_ext = '.amd64' else: raise ValueError, "Unsupported architecture" msi_type += ";1033"