1 # -*- coding: iso-8859-1 -*-

     2 # Copyright (C) 2005 Martin v. Löwis

     3 # Licensed to PSF under a Contributor Agreement.

     4 from _msi import *

     5 import os, string, re

     6 

     7 Win64=0

     8 

     9 # Partially taken from Wine

    10 datasizemask=      0x00ff

    11 type_valid=        0x0100

    12 type_localizable=  0x0200

    13 

    14 typemask=          0x0c00

    15 type_long=         0x0000

    16 type_short=        0x0400

    17 type_string=       0x0c00

    18 type_binary=       0x0800

    19 

    20 type_nullable=     0x1000

    21 type_key=          0x2000

    22 # XXX temporary, localizable?

    23 knownbits = datasizemask | type_valid | type_localizable | \

    24             typemask | type_nullable | type_key

    25 

    26 class Table:

    27     def __init__(self, name):

    28         self.name = name

    29         self.fields = []

    30 

    31     def add_field(self, index, name, type):

    32         self.fields.append((index,name,type))

    33 

    34     def sql(self):

    35         fields = []

    36         keys = []

    37         self.fields.sort()

    38         fields = [None]*len(self.fields)

    39         for index, name, type in self.fields:

    40             index -= 1

    41             unk = type & ~knownbits

    42             if unk:

    43                 print "%s.%s unknown bits %x" % (self.name, name, unk)

    44             size = type & datasizemask

    45             dtype = type & typemask

    46             if dtype == type_string:

    47                 if size:

    48                     tname="CHAR(%d)" % size

    49                 else:

    50                     tname="CHAR"

    51             elif dtype == type_short:

    52                 assert size==2

    53                 tname = "SHORT"

    54             elif dtype == type_long:

    55                 assert size==4

    56                 tname="LONG"

    57             elif dtype == type_binary:

    58                 assert size==0

    59                 tname="OBJECT"

    60             else:

    61                 tname="unknown"

    62                 print "%s.%sunknown integer type %d" % (self.name, name, size)

    63             if type & type_nullable:

    64                 flags = ""

    65             else:

    66                 flags = " NOT NULL"

    67             if type & type_localizable:

    68                 flags += " LOCALIZABLE"

    69             fields[index] = "`%s` %s%s" % (name, tname, flags)

    70             if type & type_key:

    71                 keys.append("`%s`" % name)

    72         fields = ", ".join(fields)

    73         keys = ", ".join(keys)

    74         return "CREATE TABLE %s (%s PRIMARY KEY %s)" % (self.name, fields, keys)

    75 

    76     def create(self, db):

    77         v = db.OpenView(self.sql())

    78         v.Execute(None)

    79         v.Close()

    80 

    81 class _Unspecified:pass

    82 def change_sequence(seq, action, seqno=_Unspecified, cond = _Unspecified):

    83     "Change the sequence number of an action in a sequence list"

    84     for i in range(len(seq)):

    85         if seq[i][0] == action:

    86             if cond is _Unspecified:

    87                 cond = seq[i][1]

    88             if seqno is _Unspecified:

    89                 seqno = seq[i][2]

    90             seq[i] = (action, cond, seqno)

    91             return

    92     raise ValueError, "Action not found in sequence"

    93 

    94 def add_data(db, table, values):

    95     v = db.OpenView("SELECT * FROM `%s`" % table)

    96     count = v.GetColumnInfo(MSICOLINFO_NAMES).GetFieldCount()

    97     r = CreateRecord(count)

    98     for value in values:

    99         assert len(value) == count, value

   100         for i in range(count):

   101             field = value[i]

   102             if isinstance(field, (int, long)):

   103                 r.SetInteger(i+1,field)

   104             elif isinstance(field, basestring):

   105                 r.SetString(i+1,field)

   106             elif field is None:

   107                 pass

   108             elif isinstance(field, Binary):

   109                 r.SetStream(i+1, field.name)

   110             else:

   111                 raise TypeError, "Unsupported type %s" % field.__class__.__name__

   112         try:

   113             v.Modify(MSIMODIFY_INSERT, r)

   114         except Exception, e:

   115             raise MSIError("Could not insert "+repr(values)+" into "+table)

   116 

   117         r.ClearData()

   118     v.Close()

   119 

   120 

   121 def add_stream(db, name, path):

   122     v = db.OpenView("INSERT INTO _Streams (Name, Data) VALUES ('%s', ?)" % name)

   123     r = CreateRecord(1)

   124     r.SetStream(1, path)

   125     v.Execute(r)

   126     v.Close()

   127 

   128 def init_database(name, schema,

   129                   ProductName, ProductCode, ProductVersion,

   130                   Manufacturer):

   131     try:

   132         os.unlink(name)

   133     except OSError:

   134         pass

   135     ProductCode = ProductCode.upper()

   136     # Create the database

   137     db = OpenDatabase(name, MSIDBOPEN_CREATE)

   138     # Create the tables

   139     for t in schema.tables:

   140         t.create(db)

   141     # Fill the validation table

   142     add_data(db, "_Validation", schema._Validation_records)

   143     # Initialize the summary information, allowing atmost 20 properties

   144     si = db.GetSummaryInformation(20)

   145     si.SetProperty(PID_TITLE, "Installation Database")

   146     si.SetProperty(PID_SUBJECT, ProductName)

   147     si.SetProperty(PID_AUTHOR, Manufacturer)

   148     if Win64:

   149         si.SetProperty(PID_TEMPLATE, "Intel64;1033")

   150     else:

   151         si.SetProperty(PID_TEMPLATE, "Intel;1033")

   152     si.SetProperty(PID_REVNUMBER, gen_uuid())

   153     si.SetProperty(PID_WORDCOUNT, 2) # long file names, compressed, original media

   154     si.SetProperty(PID_PAGECOUNT, 200)

   155     si.SetProperty(PID_APPNAME, "Python MSI Library")

   156     # XXX more properties

   157     si.Persist()

   158     add_data(db, "Property", [

   159         ("ProductName", ProductName),

   160         ("ProductCode", ProductCode),

   161         ("ProductVersion", ProductVersion),

   162         ("Manufacturer", Manufacturer),

   163         ("ProductLanguage", "1033")])

   164     db.Commit()

   165     return db

   166 

   167 def add_tables(db, module):

   168     for table in module.tables:

   169         add_data(db, table, getattr(module, table))

   170 

   171 def make_id(str):

   172     #str = str.replace(".", "_") # colons are allowed

   173     str = str.replace(" ", "_")

   174     str = str.replace("-", "_")

   175     if str[0] in string.digits:

   176         str = "_"+str

   177     assert re.match("^[A-Za-z_][A-Za-z0-9_.]*$", str), "FILE"+str

   178     return str

   179 

   180 def gen_uuid():

   181     return "{"+UuidCreate().upper()+"}"

   182 

   183 class CAB:

   184     def __init__(self, name):

   185         self.name = name

   186         self.files = []

   187         self.filenames = set()

   188         self.index = 0

   189 

   190     def gen_id(self, file):

   191         logical = _logical = make_id(file)

   192         pos = 1

   193         while logical in self.filenames:

   194             logical = "%s.%d" % (_logical, pos)

   195             pos += 1

   196         self.filenames.add(logical)

   197         return logical

   198 

   199     def append(self, full, file, logical):

   200         if os.path.isdir(full):

   201             return

   202         if not logical:

   203             logical = self.gen_id(file)

   204         self.index += 1

   205         self.files.append((full, logical))

   206         return self.index, logical

   207 

   208     def commit(self, db):

   209         from tempfile import mktemp

   210         filename = mktemp()

   211         FCICreate(filename, self.files)

   212         add_data(db, "Media",

   213                 [(1, self.index, None, "#"+self.name, None, None)])

   214         add_stream(db, self.name, filename)

   215         os.unlink(filename)

   216         db.Commit()

   217 

   218 _directories = set()

   219 class Directory:

   220     def __init__(self, db, cab, basedir, physical, _logical, default, componentflags=None):

   221         """Create a new directory in the Directory table. There is a current component

   222         at each point in time for the directory, which is either explicitly created

   223         through start_component, or implicitly when files are added for the first

   224         time. Files are added into the current component, and into the cab file.

   225         To create a directory, a base directory object needs to be specified (can be

   226         None), the path to the physical directory, and a logical directory name.

   227         Default specifies the DefaultDir slot in the directory table. componentflags

   228         specifies the default flags that new components get."""

   229         index = 1

   230         _logical = make_id(_logical)

   231         logical = _logical

   232         while logical in _directories:

   233             logical = "%s%d" % (_logical, index)

   234             index += 1

   235         _directories.add(logical)

   236         self.db = db

   237         self.cab = cab

   238         self.basedir = basedir

   239         self.physical = physical

   240         self.logical = logical

   241         self.component = None

   242         self.short_names = set()

   243         self.ids = set()

   244         self.keyfiles = {}

   245         self.componentflags = componentflags

   246         if basedir:

   247             self.absolute = os.path.join(basedir.absolute, physical)

   248             blogical = basedir.logical

   249         else:

   250             self.absolute = physical

   251             blogical = None

   252         add_data(db, "Directory", [(logical, blogical, default)])

   253 

   254     def start_component(self, component = None, feature = None, flags = None, keyfile = None, uuid=None):

   255         """Add an entry to the Component table, and make this component the current for this

   256         directory. If no component name is given, the directory name is used. If no feature

   257         is given, the current feature is used. If no flags are given, the directory's default

   258         flags are used. If no keyfile is given, the KeyPath is left null in the Component

   259         table."""

   260         if flags is None:

   261             flags = self.componentflags

   262         if uuid is None:

   263             uuid = gen_uuid()

   264         else:

   265             uuid = uuid.upper()

   266         if component is None:

   267             component = self.logical

   268         self.component = component

   269         if Win64:

   270             flags |= 256

   271         if keyfile:

   272             keyid = self.cab.gen_id(self.absolute, keyfile)

   273             self.keyfiles[keyfile] = keyid

   274         else:

   275             keyid = None

   276         add_data(self.db, "Component",

   277                         [(component, uuid, self.logical, flags, None, keyid)])

   278         if feature is None:

   279             feature = current_feature

   280         add_data(self.db, "FeatureComponents",

   281                         [(feature.id, component)])

   282 

   283     def make_short(self, file):

   284         parts = file.split(".")

   285         if len(parts)>1:

   286             suffix = parts[-1].upper()

   287         else:

   288             suffix = None

   289         prefix = parts[0].upper()

   290         if len(prefix) <= 8 and (not suffix or len(suffix)<=3):

   291             if suffix:

   292                 file = prefix+"."+suffix

   293             else:

   294                 file = prefix

   295             assert file not in self.short_names

   296         else:

   297             prefix = prefix[:6]

   298             if suffix:

   299                 suffix = suffix[:3]

   300             pos = 1

   301             while 1:

   302                 if suffix:

   303                     file = "%s~%d.%s" % (prefix, pos, suffix)

   304                 else:

   305                     file = "%s~%d" % (prefix, pos)

   306                 if file not in self.short_names: break

   307                 pos += 1

   308                 assert pos < 10000

   309                 if pos in (10, 100, 1000):

   310                     prefix = prefix[:-1]

   311         self.short_names.add(file)

   312         assert not re.search(r'[\?|><:/*"+,;=\[\]]', file) # restrictions on short names

   313         return file

   314 

   315     def add_file(self, file, src=None, version=None, language=None):

   316         """Add a file to the current component of the directory, starting a new one

   317         one if there is no current component. By default, the file name in the source

   318         and the file table will be identical. If the src file is specified, it is

   319         interpreted relative to the current directory. Optionally, a version and a

   320         language can be specified for the entry in the File table."""

   321         if not self.component:

   322             self.start_component(self.logical, current_feature, 0)

   323         if not src:

   324             # Allow relative paths for file if src is not specified

   325             src = file

   326             file = os.path.basename(file)

   327         absolute = os.path.join(self.absolute, src)

   328         assert not re.search(r'[\?|><:/*]"', file) # restrictions on long names

   329         if self.keyfiles.has_key(file):

   330             logical = self.keyfiles[file]

   331         else:

   332             logical = None

   333         sequence, logical = self.cab.append(absolute, file, logical)

   334         assert logical not in self.ids

   335         self.ids.add(logical)

   336         short = self.make_short(file)

   337         full = "%s|%s" % (short, file)

   338         filesize = os.stat(absolute).st_size

   339         # constants.msidbFileAttributesVital

   340         # Compressed omitted, since it is the database default

   341         # could add r/o, system, hidden

   342         attributes = 512

   343         add_data(self.db, "File",

   344                         [(logical, self.component, full, filesize, version,

   345                          language, attributes, sequence)])

   346         #if not version:

   347         #    # Add hash if the file is not versioned

   348         #    filehash = FileHash(absolute, 0)

   349         #    add_data(self.db, "MsiFileHash",

   350         #             [(logical, 0, filehash.IntegerData(1),

   351         #               filehash.IntegerData(2), filehash.IntegerData(3),

   352         #               filehash.IntegerData(4))])

   353         # Automatically remove .pyc/.pyo files on uninstall (2)

   354         # XXX: adding so many RemoveFile entries makes installer unbelievably

   355         # slow. So instead, we have to use wildcard remove entries

   356         if file.endswith(".py"):

   357             add_data(self.db, "RemoveFile",

   358                       [(logical+"c", self.component, "%sC|%sc" % (short, file),

   359                         self.logical, 2),

   360                        (logical+"o", self.component, "%sO|%so" % (short, file),

   361                         self.logical, 2)])

   362         return logical

   363 

   364     def glob(self, pattern, exclude = None):

   365         """Add a list of files to the current component as specified in the

   366         glob pattern. Individual files can be excluded in the exclude list."""

   367         files = glob.glob1(self.absolute, pattern)

   368         for f in files:

   369             if exclude and f in exclude: continue

   370             self.add_file(f)

   371         return files

   372 

   373     def remove_pyc(self):

   374         "Remove .pyc/.pyo files on uninstall"

   375         add_data(self.db, "RemoveFile",

   376                  [(self.component+"c", self.component, "*.pyc", self.logical, 2),

   377                   (self.component+"o", self.component, "*.pyo", self.logical, 2)])

   378 

   379 class Binary:

   380     def __init__(self, fname):

   381         self.name = fname

   382     def __repr__(self):

   383         return 'msilib.Binary(os.path.join(dirname,"%s"))' % self.name

   384 

   385 class Feature:

   386     def __init__(self, db, id, title, desc, display, level = 1,

   387                  parent=None, directory = None, attributes=0):

   388         self.id = id

   389         if parent:

   390             parent = parent.id

   391         add_data(db, "Feature",

   392                         [(id, parent, title, desc, display,

   393                           level, directory, attributes)])

   394     def set_current(self):

   395         global current_feature

   396         current_feature = self

   397 

   398 class Control:

   399     def __init__(self, dlg, name):

   400         self.dlg = dlg

   401         self.name = name

   402 

   403     def event(self, event, argument, condition = "1", ordering = None):

   404         add_data(self.dlg.db, "ControlEvent",

   405                  [(self.dlg.name, self.name, event, argument,

   406                    condition, ordering)])

   407 

   408     def mapping(self, event, attribute):

   409         add_data(self.dlg.db, "EventMapping",

   410                  [(self.dlg.name, self.name, event, attribute)])

   411 

   412     def condition(self, action, condition):

   413         add_data(self.dlg.db, "ControlCondition",

   414                  [(self.dlg.name, self.name, action, condition)])

   415 

   416 class RadioButtonGroup(Control):

   417     def __init__(self, dlg, name, property):

   418         self.dlg = dlg

   419         self.name = name

   420         self.property = property

   421         self.index = 1

   422 

   423     def add(self, name, x, y, w, h, text, value = None):

   424         if value is None:

   425             value = name

   426         add_data(self.dlg.db, "RadioButton",

   427                  [(self.property, self.index, value,

   428                    x, y, w, h, text, None)])

   429         self.index += 1

   430 

   431 class Dialog:

   432     def __init__(self, db, name, x, y, w, h, attr, title, first, default, cancel):

   433         self.db = db

   434         self.name = name

   435         self.x, self.y, self.w, self.h = x,y,w,h

   436         add_data(db, "Dialog", [(name, x,y,w,h,attr,title,first,default,cancel)])

   437 

   438     def control(self, name, type, x, y, w, h, attr, prop, text, next, help):

   439         add_data(self.db, "Control",

   440                  [(self.name, name, type, x, y, w, h, attr, prop, text, next, help)])

   441         return Control(self, name)

   442 

   443     def text(self, name, x, y, w, h, attr, text):

   444         return self.control(name, "Text", x, y, w, h, attr, None,

   445                      text, None, None)

   446 

   447     def bitmap(self, name, x, y, w, h, text):

   448         return self.control(name, "Bitmap", x, y, w, h, 1, None, text, None, None)

   449 

   450     def line(self, name, x, y, w, h):

   451         return self.control(name, "Line", x, y, w, h, 1, None, None, None, None)

   452 

   453     def pushbutton(self, name, x, y, w, h, attr, text, next):

   454         return self.control(name, "PushButton", x, y, w, h, attr, None, text, next, None)

   455 

   456     def radiogroup(self, name, x, y, w, h, attr, prop, text, next):

   457         add_data(self.db, "Control",

   458                  [(self.name, name, "RadioButtonGroup",

   459                    x, y, w, h, attr, prop, text, next, None)])

   460         return RadioButtonGroup(self, name, prop)

   461 

   462     def checkbox(self, name, x, y, w, h, attr, prop, text, next):

   463         return self.control(name, "CheckBox", x, y, w, h, attr, prop, text, next, None)