# Copyright (C) 2005, Giovanni Bajo

# Based on previous work under copyright (c) 2001, 2002 McMillan Enterprises, Inc.

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

import win32api

import struct

import pywintypes

import string

import pprint

TEST=0

LOAD_LIBRARY_AS_DATAFILE = 2

RT_VERSION = 16

def getRaw0(o):

    return o.raw

def getRaw1(o):

    return str(buffer(o))

import sys

if hasattr(sys, "version_info"):

    pyvers = sys.version_info[0]*10 + sys.version_info[1]

else:

    toks = string.split(sys.version, '.', 2)

    pyvers = int(toks[0])*10 + int(toks[1])

if pyvers < 20:

    getRaw = getRaw0

else:

    getRaw = getRaw1

##VS_VERSION_INFO {

##    WORD  wLength;        // Specifies the length of the VS_VERSION_INFO structure

##    WORD  wValueLength;   // Specifies the length of the Value member

##    WORD  wType;          // 1 means text, 0 means binary

##    WCHAR szKey[];        // Contains the Unicode string "VS_VERSION_INFO".

##    WORD  Padding1[];

##    VS_FIXEDFILEINFO Value;

##    WORD  Padding2[];

##    WORD  Children[];     // Specifies a list of zero or more StringFileInfo or VarFileInfo structures (or both) that are children of the current version structure.

##};

def decode(pathnm):

    h = win32api.LoadLibraryEx(pathnm, 0, LOAD_LIBRARY_AS_DATAFILE)

    nm = win32api.EnumResourceNames(h, RT_VERSION)[0]

    data = win32api.LoadResource(h, RT_VERSION, nm)

    vs = VSVersionInfo()

    j = vs.fromRaw(data)

    if TEST:

        print vs

        if data[:j] != vs.toRaw():

            print "AAAAAGGHHHH"

        txt = repr(vs)

        glbls = {}

        glbls['VSVersionInfo'] = VSVersionInfo

        glbls['FixedFileInfo'] = FixedFileInfo

        glbls['StringFileInfo'] = StringFileInfo

        glbls['StringTable'] = StringTable

        glbls['StringStruct'] = StringStruct

        glbls['VarFileInfo'] = VarFileInfo

        glbls['VarStruct'] = VarStruct

        vs2 = eval(txt+'\n', glbls)

        if vs.toRaw() != vs2.toRaw():

            print

            print 'reconstruction not the same!'

            print vs2

    win32api.FreeLibrary(h)

    return vs

class VSVersionInfo:

    def __init__(self, ffi=None, kids=None):

        self.ffi = ffi

        self.kids = kids

        if kids is None:

            self.kids = []

    def fromRaw(self, data):

        i, (sublen, vallen, wType, nm) = parseCommon(data)

        #vallen is length of the ffi, typ is 0, nm is 'VS_VERSION_INFO'

        i = ((i + 3) / 4) * 4

        # now a VS_FIXEDFILEINFO

        self.ffi = FixedFileInfo()

        j = self.ffi.fromRaw(data, i)

        #print ffi

        if TEST:

            if data[i:j] != self.ffi.toRaw():

                print "raw:", `data[i:j]`

                print "ffi:", `self.ffi.toRaw()`

        i = j

        while i < sublen:

            j = i

            i, (csublen, cvallen, ctyp, nm) = parseCommon(data, i)

            if string.strip(str(nm)) == "StringFileInfo":

                sfi = StringFileInfo()

                k = sfi.fromRaw(csublen, cvallen, nm, data, i, j+csublen)

                if TEST:

                    if data[j:k] != sfi.toRaw():

                        rd = data[j:k]

                        sd = sfi.toRaw()

                        for x in range(0, len(rd), 16):

                            rds = rd[x:x+16]

                            sds = sd[x:x+16]

                            if rds != sds:

                                print "rd[%s:%s+16]: %s" % (x, x, `rds`)

                                print "sd[%s:%s+16]: %s" % (x, x, `sds`)

                                print

                        print "raw: len %d, wLength %d" % (len(rd), struct.unpack('h', rd[:2])[0])

                        print "sfi: len %d, wLength %d" % (len(sd), struct.unpack('h', sd[:2])[0])

                self.kids.append(sfi)

                i = k

            else:

                vfi = VarFileInfo()

                k = vfi.fromRaw(csublen, cvallen, nm, data, i, j+csublen)

                self.kids.append(vfi)

                if TEST:

                    if data[j:k] != vfi.toRaw():

                        print "raw:", `data[j:k]`

                        print "vfi:", `vfi.toRaw()`

                i = k

            i = j + csublen

            i = ((i + 3) / 4) * 4

        return i

    def toRaw(self):

        nm = pywintypes.Unicode('VS_VERSION_INFO')

        rawffi = self.ffi.toRaw()

        vallen = len(rawffi)

        typ = 0

        sublen = 6 + 2*len(nm) + 2

        pad = ''

        if sublen % 4:

            pad = '\000\000'

        sublen = sublen + len(pad) + vallen

        pad2 = ''

        if sublen % 4:

            pad2 = '\000\000'

        tmp = []

        for kid in self.kids:

            tmp.append(kid.toRaw())

        tmp = string.join(tmp, '')

        sublen = sublen + len(pad2) + len(tmp)

        return struct.pack('hhh', sublen, vallen, typ) + getRaw(nm) + '\000\000' + pad + rawffi + pad2 + tmp

    def __repr__(self, indent=''):

        tmp = []

        newindent = indent + '  '

        for kid in self.kids:

            tmp.append(kid.__repr__(newindent+'  '))

        tmp = string.join(tmp, ', \n')

        return "VSVersionInfo(\n%sffi=%s,\n%skids=[\n%s\n%s]\n)" % (newindent, self.ffi.__repr__(newindent), newindent, tmp, newindent)

def parseCommon(data, start=0):

    i = start + 6

    (wLength, wValueLength, wType) = struct.unpack('3h', data[start:i])

    #print "wLength, wValueLength, wType, i:", wLength, wValueLength, wType, i

    i, szKey = parseUString(data, i, i+wLength)

    #i = ((i + 3) / 4) * 4

    #print `data[start+6:start+wLength]`

    return i, (wLength, wValueLength, wType, szKey)

def parseUString(data, start, limit):

    i = start

    while i < limit:

        if data[i:i+2] == '\000\000':

            break

        i = i + 2

    szKey = pywintypes.UnicodeFromRaw(data[start:i])

    i = i + 2

    #print "szKey:", '"'+str(szKey)+'"', "(consumed", i-start, "bytes - to", i, ")"

    return i, szKey

##VS_FIXEDFILEINFO {  // vsffi

##    DWORD dwSignature;        //Contains the value 0xFEEFO4BD

##    DWORD dwStrucVersion;     //Specifies the binary version number of this structure. The high-order word of this member contains the major version number, and the low-order word contains the minor version number.

##    DWORD dwFileVersionMS;    // Specifies the most significant 32 bits of the file's binary version number

##    DWORD dwFileVersionLS;    //

##    DWORD dwProductVersionMS; // Specifies the most significant 32 bits of the binary version number of the product with which this file was distributed

##    DWORD dwProductVersionLS; //

##    DWORD dwFileFlagsMask;    // Contains a bitmask that specifies the valid bits in dwFileFlags. A bit is valid only if it was defined when the file was created.

##    DWORD dwFileFlags;        // VS_FF_DEBUG, VS_FF_PATCHED etc.

##    DWORD dwFileOS;           // VOS_NT, VOS_WINDOWS32 etc.

##    DWORD dwFileType;         // VFT_APP etc.

##    DWORD dwFileSubtype;      // 0 unless VFT_DRV or VFT_FONT or VFT_VXD

##    DWORD dwFileDateMS;

##    DWORD dwFileDateLS;

##};

class FixedFileInfo:

    def __init__(self, filevers=(0, 0, 0, 0), prodvers=(0, 0, 0, 0), mask=0x3f, flags=0x0, OS=0x40004, fileType=0x1, subtype=0x0, date=(0, 0)):

        self.sig = 0xfeef04bdL

        self.strucVersion = 0x10000

        self.fileVersionMS = (filevers[0] << 16) | (filevers[1] & 0xffff)

        self.fileVersionLS = (filevers[2] << 16) | (filevers[3] & 0xffff)

        self.productVersionMS = (prodvers[0] << 16) | (prodvers[1] & 0xffff)

        self.productVersionLS = (prodvers[2] << 16) | (prodvers[3] & 0xffff)

        self.fileFlagsMask = mask

        self.fileFlags = flags

        self.fileOS = OS

        self.fileType = fileType

        self.fileSubtype = subtype

        self.fileDateMS = date[0]

        self.fileDateLS = date[1]

    def fromRaw(self, data, i):

        (self.sig,

         self.strucVersion,

         self.fileVersionMS,

         self.fileVersionLS,

         self.productVersionMS,

         self.productVersionLS,

         self.fileFlagsMask,

         self.fileFlags,

         self.fileOS,

         self.fileType,

         self.fileSubtype,

         self.fileDateMS,

         self.fileDateLS) = struct.unpack('13l', data[i:i+52])

        return i+52

    def toRaw(self):

        return struct.pack('L12l', self.sig,

                             self.strucVersion,

                             self.fileVersionMS,

                             self.fileVersionLS,

                             self.productVersionMS,

                             self.productVersionLS,

                             self.fileFlagsMask,

                             self.fileFlags,

                             self.fileOS,

                             self.fileType,

                             self.fileSubtype,

                             self.fileDateMS,

                             self.fileDateLS)

    def __repr__(self, indent=''):

        fv = (self.fileVersionMS >> 16, self.fileVersionMS & 0xffff, self.fileVersionLS >> 16, self.fileVersionLS & 0xFFFF)

        pv = (self.productVersionMS >> 16, self.productVersionMS & 0xffff, self.productVersionLS >> 16, self.productVersionLS & 0xFFFF)

        fd = (self.fileDateMS, self.fileDateLS)

        tmp = ["FixedFileInfo(",

               "filevers=%s," % (fv,),

               "prodvers=%s," % (pv,),

               "mask=%s," % hex(self.fileFlagsMask),

               "flags=%s," % hex(self.fileFlags),

               "OS=%s," % hex(self.fileOS),

               "fileType=%s," % hex(self.fileType),

               "subtype=%s," % hex(self.fileSubtype),

               "date=%s" % (fd,),

               ")"

              ]

        return string.join(tmp, '\n'+indent+'  ')

##StringFileInfo {

##    WORD        wLength;      // Specifies the length of the version resource

##    WORD        wValueLength; // Specifies the length of the Value member in the current VS_VERSION_INFO structure

##    WORD        wType;        // 1 means text, 0 means binary

##    WCHAR       szKey[];      // Contains the Unicode string "StringFileInfo".

##    WORD        Padding[];

##    StringTable Children[];   // Specifies a list of zero or more String structures

##};

class StringFileInfo:

    def __init__(self, kids=None):

        self.name = "StringFileInfo"

        if kids is None:

            self.kids = []

        else:

            self.kids = kids

    def fromRaw(self, sublen, vallen, name, data, i, limit):

        self.name = name

        while i < limit:

            st = StringTable()

            j = st.fromRaw(data, i, limit)

            if TEST:

                if data[i:j] != st.toRaw():

                    rd = data[i:j]

                    sd = st.toRaw()

                    for x in range(0, len(rd), 16):

                        rds = rd[x:x+16]

                        sds = sd[x:x+16]

                        if rds != sds:

                            print "rd[%s:%s+16]: %s" % (x, x, `rds`)

                            print "sd[%s:%s+16]: %s" % (x, x, `sds`)

                            print

                    print "raw: len %d, wLength %d" % (len(rd), struct.unpack('h', rd[:2])[0])

                    print " st: len %d, wLength %d" % (len(sd), struct.unpack('h', sd[:2])[0])

            self.kids.append(st)

            i = j

        return i

    def toRaw(self):

        if type(self.name) is STRINGTYPE:

            self.name = pywintypes.Unicode(self.name)

        vallen = 0

        typ = 1

        sublen = 6 + 2*len(self.name) + 2

        pad = ''

        if sublen % 4:

            pad = '\000\000'

        tmp = []

        for kid in self.kids:

            tmp.append(kid.toRaw())

        tmp = string.join(tmp, '')

        sublen = sublen + len(pad) + len(tmp)

        if tmp[-2:] == '\000\000':

            sublen = sublen - 2

        return struct.pack('hhh', sublen, vallen, typ) + getRaw(self.name) + '\000\000' + pad + tmp

    def __repr__(self, indent=''):

        tmp = []

        newindent = indent + '  '

        for kid in self.kids:

            tmp.append(kid.__repr__(newindent))

        tmp = string.join(tmp, ', \n')

        return "%sStringFileInfo(\n%s[\n%s\n%s])" % (indent, newindent, tmp, newindent)

##StringTable {

##    WORD   wLength;

##    WORD   wValueLength;

##    WORD   wType;

##    WCHAR  szKey[];

##    String Children[];    // Specifies a list of zero or more String structures.

##};

class StringTable:

    def __init__(self, name=None, kids=None):

        self.name = name

        self.kids = kids

        if name is None:

            self.name = ''

        if kids is None:

            self.kids = []

    def fromRaw(self, data, i, limit):

        #print "Parsing StringTable"

        i, (cpsublen, cpwValueLength, cpwType, self.name) = parseCodePage(data, i, limit) # should be code page junk

        #i = ((i + 3) / 4) * 4

        while i < limit:

            ss = StringStruct()

            j = ss.fromRaw(data, i, limit)

            if TEST:

                if data[i:j] != ss.toRaw():

                    print "raw:", `data[i:j]`

                    print " ss:", `ss.toRaw()`

            i = j

            self.kids.append(ss)

            i = ((i + 3) / 4) * 4

        return i

    def toRaw(self):

        if type(self.name) is STRINGTYPE:

            self.name = pywintypes.Unicode(self.name)

        vallen = 0

        typ = 1

        sublen = 6 + 2*len(self.name) + 2

        tmp = []

        for kid in self.kids:

            raw = kid.toRaw()

            if len(raw) % 4:

                raw = raw + '\000\000'

            tmp.append(raw)

        tmp = string.join(tmp, '')

        sublen = sublen + len(tmp)

        if tmp[-2:] == '\000\000':

            sublen = sublen - 2

        return struct.pack('hhh', sublen, vallen, typ) + getRaw(self.name) + '\000\000' + tmp

    def __repr__(self, indent=''):

        tmp = []

        newindent = indent + '  '

        for kid in self.kids:

            tmp.append(repr(kid))

        tmp = string.join(tmp, ',\n%s' % newindent)

        return "%sStringTable(\n%s'%s', \n%s[%s])" % (indent, newindent, str(self.name), newindent, tmp)

##String {

##    WORD   wLength;

##    WORD   wValueLength;

##    WORD   wType;

##    WCHAR  szKey[];

##    WORD   Padding[];

##    String Value[];

##};

class StringStruct:

    def __init__(self, name=None, val=None):

        self.name = name

        self.val = val

        if name is None:

            self.name = ''

        if val is None:

            self.val = ''

    def fromRaw(self, data, i, limit):

        i, (sublen, vallen, typ, self.name) = parseCommon(data, i)

        limit = i + sublen

        i = ((i + 3) / 4) * 4

        i, self.val = parseUString(data, i, limit)

        return i

    def toRaw(self):

        if type(self.name) is STRINGTYPE:

            self.name = pywintypes.Unicode(self.name)

        if type(self.val) is STRINGTYPE:

            self.val = pywintypes.Unicode(self.val)

        vallen = len(self.val) + 1

        typ = 1

        sublen = 6 + 2*len(self.name) + 2

        pad = ''

        if sublen % 4:

            pad = '\000\000'

        sublen = sublen + len(pad) + 2*vallen

        return struct.pack('hhh', sublen, vallen, typ) + getRaw(self.name) + '\000\000' + pad + getRaw(self.val) + '\000\000'

    def __repr__(self, indent=''):

        if pyvers < 20:

            return "StringStruct('%s', '%s')" % (str(self.name), str(self.val))

        else:

            return "StringStruct('%s', '%s')" % (self.name, self.val)

def parseCodePage(data, i, limit):

    #print "Parsing CodePage"

    i, (sublen, wValueLength, wType, nm) = parseCommon(data, i)

    #i = ((i + 3) / 4) * 4

    return i, (sublen, wValueLength, wType, nm)

##VarFileInfo {

##    WORD  wLength;        // Specifies the length of the version resource

##    WORD  wValueLength;   // Specifies the length of the Value member in the current VS_VERSION_INFO structure

##    WORD  wType;          // 1 means text, 0 means binary

##    WCHAR szKey[];        // Contains the Unicode string "VarFileInfo".

##    WORD  Padding[];

##    Var   Children[];     // Specifies a list of zero or more Var structures

##};

class VarFileInfo:

    def __init__(self, kids=None):

        if kids is None:

            self.kids = []

        else:

            self.kids = kids

    def fromRaw(self, sublen, vallen, name, data, i, limit):

        self.sublen = sublen

        self.vallen = vallen

        self.name = name

        i = ((i + 3) / 4) * 4

        while i < limit:

            vs = VarStruct()

            j = vs.fromRaw(data, i, limit)

            self.kids.append(vs)

            if TEST:

                if data[i:j] != vs.toRaw():

                    print "raw:", `data[i:j]`

                    print "cmp:", `vs.toRaw()`

            i = j

        return i

    def toRaw(self):

        self.vallen = 0

        self.wType = 1

        self.name = pywintypes.Unicode('VarFileInfo')

        sublen = 6 + 2*len(self.name) + 2

        pad = ''

        if sublen % 4:

            pad = '\000\000'

        tmp = []

        for kid in self.kids:

            tmp.append(kid.toRaw())

        tmp = string.join(tmp, '')

        self.sublen = sublen + len(pad) + len(tmp)

        return struct.pack('hhh', self.sublen, self.vallen, self.wType) + getRaw(self.name) + '\000\000' + pad + tmp

    def __repr__(self, indent=''):

        tmp = map(repr, self.kids)

        return "%sVarFileInfo([%s])" % (indent, string.join(tmp, ', '))

##Var {

##    WORD  wLength;        // Specifies the length of the version resource

##    WORD  wValueLength;   // Specifies the length of the Value member in the current VS_VERSION_INFO structure

##    WORD  wType;          // 1 means text, 0 means binary

##    WCHAR szKey[];        // Contains the Unicode string "Translation" or a user-defined key string value

##    WORD  Padding[];      //

##    WORD  Value[];        // Specifies a list of one or more values that are language and code-page identifiers

##};

STRINGTYPE = type('')

class VarStruct:

    def __init__(self, name=None, kids=None):

        self.name = name

        self.kids = kids

        if name is None:

            self.name = ''

        if kids is None:

            self.kids = []

    def fromRaw(self, data, i, limit):

        i, (self.sublen, self.wValueLength, self.wType, self.name) = parseCommon(data, i)

        i = ((i + 3) / 4) * 4

        for j in range(self.wValueLength/2):

            kid = struct.unpack('h', data[i:i+2])[0]

            self.kids.append(kid)

            i = i + 2

        return i

    def toRaw(self):

        self.wValueLength = len(self.kids) * 2

        self.wType = 0

        if type(self.name) is STRINGTYPE:

            self.name = pywintypes.Unicode(self.name)

        sublen = 6 + 2*len(self.name) + 2

        pad = ''

        if sublen % 4:

            pad = '\000\000'

        self.sublen = sublen + len(pad) + self.wValueLength

        tmp = []

        for kid in self.kids:

            tmp.append(struct.pack('h', kid))

        tmp = string.join(tmp, '')

        return struct.pack('hhh', self.sublen, self.wValueLength, self.wType) + getRaw(self.name) + '\000\000' + pad + tmp

    def __repr__(self, indent=''):

        return "VarStruct('%s', %s)" % (str(self.name), repr(self.kids))

def SetVersion(exenm, versionfile):

    txt = open(versionfile, 'r').read()

    vs = eval(txt+'\n', globals())

    hdst = win32api.BeginUpdateResource(exenm, 0)

    win32api.UpdateResource(hdst, RT_VERSION, 1, vs.toRaw())

    win32api.EndUpdateResource (hdst, 0)

if __name__ == '__main__':

    import sys

    TEST = 1

    if len(sys.argv) < 2:

        decode('c:/Program Files/Netscape/Communicator/Program/netscape.exe')

    else:

        print "Examining", sys.argv[1]