Tryag File Manager

//usr/lib/python2.4/site-packages/instnum.py

#!/usr/bin/python

# instnum.py - parse and decode RHEL Installation Numbers
# Copyright (c) 2006 Red Hat, Inc.
# Authors: Dave Lehman <dlehman@redhat.com>
#
# 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., 675 Mass Ave, Cambridge, MA 02139, USA.

import hmac
import sha
import re

##
## I18N
##
from rhpl.translate import _, N_
import rhpl.translate as translate
domain = "rhel-instnum"
translate.textdomain (domain)

"""
    TODO:

NOTES:
        - it'd be nice to tweak the encoding map setup
        - there's some inconsistency WRT handling requests for invalid fields;
            some methods return None, others raise exceptions

"""
class InstallationNumberError(Exception):
    def __init__(self, args=None):
        Exception.__init__(self)
        self.args = args

class InstallationNumber:
    def __init__(self, rawString):
        self.rawString = ''         # the encoded IN string as hex digits
        self.rawDict = {}           # map of field names to decoded values
        self.formatMap = {}         # map of offset and length of each field
        self.keyMap = {}            # map of key offsets for each field

# strip out any non-alphanumeric characters
        rawString = re.sub(r'[^a-zA-Z0-9]', '', rawString)

# basic validation of the string
        try:
            int(rawString, 16)
        except ValueError:
            raise InstallationNumberError, "Not a valid hex string"
        except TypeError:
            raise InstallationNumberError, "Not a string"
        else:
            self.rawString = rawString

# get the maps for this string format (based solely on string length)
        stringLen = len(self.rawString)
        if not formatMap.has_key(stringLen) or not keyMap.has_key(stringLen):
            raise InstallationNumberError, "Unsupported string length"
        else:
            self.formatMap = formatMap[stringLen]
            self.keyMap = keyMap[stringLen]

# final validation is a checksum initial substring comparison
        if not self.verifyChecksum():
            raise InstallationNumberError, "Checksum verification failed"

# parse the string and decrypt the values
        self.__parse()

def __parse(self):
        """ parse the IN string and decrypt the values """
        rawString = self.rawString
        rawNum = 0
        value = None

# make sure the key is first so any fields requiring decryption are ok
        maps = self.formatMap.items()
        keyMapEnt = (IN_KEY, self.formatMap[IN_KEY])
        i = maps.index(keyMapEnt)
        sortedMaps = [maps.pop(i)]
        sortedMaps.extend(maps)
        maps = sortedMaps

# parse each of the fields
        for field, (offset, length) in maps:
            # first, convert the relevant portion of the string to an int
            startChar = self.__hexLen(offset, down=True)
            endChar = self.__hexLen(offset + length)
            rawNum = int(rawString[startChar:endChar], 16)

# now, pluck out the bits we want
            offset -= (startChar * 4)
            pad = ((endChar - startChar) * 4) - offset - length
            mask = pow(2, length) - 1
            value = (rawNum >> pad) & mask

# decrypt the value if necessary
            self.rawDict[field] = self.decrypt(field, value)

def __hexLen(self, bits, down=None):
        """ convert a length in bits to a length in hex digits,
                with the option to round down instead of up 
        """
        length = bits / 4
        if bits % 4:
            if down is None:
                length += 1
        return length

def verifyChecksum(self):
        """ compute and verify the keyed SHA1 checksum of the IN payload

NOTE: we only use the raw string since __parse() hasn't been called

returns a boolean value (True == success)
        """

# grab the checksum
        csumMap = self.formatMap[IN_CHECKSUM]
        csumStart = self.__hexLen(csumMap[0], down=True)
        csumLen = self.__hexLen(csumMap[1]) # we'll use this later, too
        csumEnd = csumStart + csumLen
        checksum = self.rawString[csumStart:csumEnd]

# grab the payload (everything after the checksum)
        payload = self.rawString[csumEnd:]

# grab the key
        keyMapEnt = self.formatMap[IN_KEY]
        keyStart = self.__hexLen(keyMapEnt[0], down=True)
        keyEnd = keyStart + self.__hexLen(keyMapEnt[1])
        key = self.rawString[keyStart:keyEnd]

# create an HMAC hash using an SHA1 digest ;  feed it %key and %payload
        mac = hmac.new(key, payload, sha)

# compare the first %csumLen digits of our just-computed hash
        #   against the digits we recieved as part of the IN string
        rc = False
        if checksum == mac.hexdigest()[:csumLen]:
            rc = True

return rc

def encrypt(self, field, value=None):
        """ encrypt a field using the appropriate segment of the IN's key

returns the encrypted value (raise KeyError on failure)
        """
        if not self.formatMap.has_key(field):
            raise KeyError, "Unknown field: '%s'" % (field,)

if value is None:
            value = self.getRaw(field)

if self.keyMap.has_key(field):
            key = self.getRaw(IN_KEY)
            keyLen = self.formatMap[IN_KEY][1]
            offset = self.keyMap[field]
            # grab the field length from the formatMap
            length = self.formatMap[field][1]
            pad = keyLen - offset - length
            mask = pow(2, length) - 1
            value ^= (key >> pad) & mask

return value

def decrypt(self, field, value):
        """ decrypt a field given its value using the appropriate segment
              of the IN's key
        """
        return self.encrypt(field, value)

def getRaw(self, field):
        """ retrieve a field's value without decoding it

invalid field returns None
        """
        return self.rawDict.get(field)

# XXX not reached

if not self.formatMap.has_key(field):
            raise ValueError, "Unknown field: %s" % (field,)

# XXX should never get here
        raise InstallationNumberError, "missing field '%s'" % (fieldNamesMap[field],)

def getRawAsString(self, field):
        """ return a field's raw value as a hex string """
        value = self.getRaw(field)
        if value is None:
            return None

bits = self.formatMap[field][1]
        length = self.__hexLen(bits)
        # XXX is this really necessary?
        stringVal = eval('"%0' + str(length) + 'x" % (value,)')
        return stringVal
        
    def decode(self, field):
        """ translate a field from encoded value to human-readable value

NOTE: this can return varying types depending on the field

returns the field's decoded value (or None on error)
        """
        value = None
        product = self.getRaw(IN_PRODUCT)

if encodingMaps.has_key(field) and self.getRaw(field) is not None:
            # if this field has an encodingMap, use it

# handle special cases first
            if field == IN_PRODUCT:
                value = encodingMaps[field][product]
            elif field == IN_OPTIONS:
                value = combinationsDict[product][self.getRaw(field)]
            else:
                # let rip
                value = encodingMaps[field][product][self.getRaw(field)]
        elif self.getRaw(field) is not None:
            # return the hex substring
            value = self.getRawAsString(field)

return value

def get_summary_string(self):
        """ represent the object in a human-readable format """
        s = _("Product: RHEL %s\n" % (self.get_product_string().title(),))
        s += _("Type: %s\n" % (self.get_type_string(),))
        s += _("Options: %s\n" % (self.get_options_string(),))
        s += _("Allowed CPU Sockets: %s\n" % (self.get_socklimit_string(),))
        s += _("Allowed Virtual Instances: %s\n" % (self.get_virtlimit_string(),))
        s += _("Package Repositories: %s\n" % (self.get_repos_string(),))
        return s

def __str__(self):
        """ return the original IN string """
        inum = ''
        i = 0
        j = 4
        while j <= len(self.rawString):
            if i != 0:
                inum += "-"
            inum += self.rawString[i:j]
            i += 4
            j += 4
        return inum

def get_key(self):
        """ return the raw (integer) IN key """
        return self.getRaw(IN_KEY)

def get_checksum(self):
        """ return the checksum portion of the IN """
        return self.getRaw(IN_CHECKSUM)

def get_options(self):
        """ return the actual options bitfield """
        options = self.getRaw(IN_OPTIONS)
        product = self.get_product()
        return encodingMaps[IN_COMBINATIONS][product][options]

def get_socklimit(self):
        """ return socklimit as an integer """
        return self.decode(IN_SOCKLIMIT)

def get_virtlimit(self):
        """ return virtlimit as an integer """
        return self.decode(IN_VIRTLIMIT)

def get_type(self):
        """ return the type of the IN as an integer """
        return self.getRaw(IN_TYPE)

def get_product(self):
        """ return the product as an integer """
        return self.getRaw(IN_PRODUCT)

def get_repos(self):
        """ return a list of applicable repos """
        product = self.get_product()
        optCodes = encodingMaps[IN_OPTIONS][product].keys()
        optCodes.sort()
        myOpts = self.get_options()
        myOptCodes = [code for code in optCodes if myOpts & code]
        repoMap = encodingMaps[IN_REPO][product]
        repos = []

def resolve_repos(rmap, repo):
            if type(repo) == type(""):
                ret = [repo]
            if type(repo) == type([]):
                ret = []
                for r in repo:
                    ret.extend(resolve_repos(rmap, r))
            elif rmap.has_key(repo):
                ret = resolve_repos(rmap, rmap[repo])

return ret

for optCode in myOptCodes:
            if repoMap.has_key(optCode):
                for repo in repoMap[optCode]:
                    repos.extend(resolve_repos(repoMap, repo))

return repos
        
    def get_key_string(self):
        """ return the key as a string """
        return self.decode(IN_KEY)

def get_checksum_string(self):
        """ return the checksum as a string """
        return self.decode(IN_CHECKSUM)

def get_options_string(self):
        """ return the options as space-delimited concatenation of 
            enabled option strings """
        product = self.get_product()
        optionsMap = encodingMaps[IN_OPTIONS][product]
        optCodes = optionsMap.keys()
        optCodes.sort()
        myOpts = self.get_options()
        strings = [optionsMap[code] for code in optCodes if myOpts & code]
        value = " ".join(strings)
        return value

def get_socklimit_string(self):
        """ return the socklimit as a string """
        value = self.decode(IN_SOCKLIMIT)
        if value == -1:
            value = _("Unlimited")
        else:
            value = str(value)
        
        return value

def get_virtlimit_string(self):
        """ return the virtlimit as a string """
        value = self.decode(IN_VIRTLIMIT)
        if value == -1:
            value = _("Unlimited")
        else:
            value = str(value)
        
        return value

def get_type_string(self):
        """ return the type as a string """
        return self.decode(IN_TYPE)

def get_product_string(self):
        """ return the product as a string """
        return self.decode(IN_PRODUCT)

def get_repos_string(self):
        """ return the applicable repos as a space-delimited list """
        return " ".join(self.get_repos())

def get_repos_dict(self):
        product = self.get_product()
        optionsMap = encodingMaps[IN_OPTIONS][product]
        repoMap = encodingMaps[IN_REPO][product]
        optCodes = optionsMap.keys()
        optCodes.sort()
        myOpts = self.get_options()
        repoDict = {}
        repoList = []

return ret

for code in optCodes:
            if myOpts & code and repoMap.has_key(code) and repoMap[code]:
                for repo in repoMap[code]:
                    repoList.extend(resolve_repos(repoMap, repo))

for repo in repoList:
            for (code, repos) in repoMap.items():
                key = optionsMap[code]
                if key == "FullProd":
                    # XXX hack to keep the keys minimally descriptive
                    key = "Base"
                if repo in repos:
                    repoDict[key] = repo

return repoDict

InstNum = InstallationNumber
InstNumError = InstallationNumberError

IN_KEY = 0
IN_CHECKSUM = 1
IN_OPTIONS = 2
IN_SOCKLIMIT = 3
IN_VIRTLIMIT = 4
IN_TYPE = 5
IN_PRODUCT = 6
IN_REPO = 7
IN_COMBINATIONS = 8

PROD_SERVER = 0x0
PROD_CLIENT = 0x1
PROD_RHGD = 0x2

fieldNamesMap = {
    IN_KEY          : "key",
    IN_CHECKSUM     : "checksum",
    IN_OPTIONS      : "options",
    IN_SOCKLIMIT    : "socklimit",
    IN_VIRTLIMIT    : "virtlimit",
    IN_TYPE         : "type",
    IN_PRODUCT      : "product",
    IN_REPO         : "repo",
    IN_COMBINATIONS : "combinations" }

"""
    Basic definition of the Entitlement Number formats and codes for RHEL5.
    
     We support three different Entitlement Number formats:
    * 16 hex digits for backwards compatibility with old RHEL/RHN.
    * 24 hex digits extended regcodes for future extendability and
       higher entropy.
    * 32 hex digits to be able to encode asset tags.
   
    The default in the RHEL5 time frame is expected to be 16 hex digits for now.
    32 is considered to be to long for customers to type in but it might come 
    back in later, automated usecases. So every implementation should be able
    to accept different EN formats.
    
    The formats are:
    
     K = Key          - Generated via the algorithm currently used in HACK for 
                        the whole regcode. 
     C = Checksum     - Keyed SHA of the ("encrypted") payload and the key. 
                        - Verification and additional entropy.
     O = Options      - Option encoding
     S = SocketLimit  - Number of physical CPUs allowed.
     V = VirtLimit    - Number of virtual instances allowed.
     T = EN Type      - Type of the EN
     P = Product Code - Looked up in a dictionary. Defines the interpretation 
                        of the rest of the payload digits.
    
    The product code and the length together define the format.
     
    16 hex digits: 
     KK KK KK CC OO OS VT PP
     |        |   |    || |- Product defining the format. 
     |        |   |    ||- Virt limit code used to look up the limit
     |        |   |    |   in a dictionary. The least bit actually is 
     |        |   |    |   used for the Type field.
     |        |   |    |- Socket (phys. CPUs) limit code used to look 
     |        |   |       up the limit in the list of all possible limits.
     |        |   |- Option code to look up the combination of 
     |        |      options in a dictionary.
     |        |- Checksum - Keyed hash Key and the other fields.
     |-  Key generated with Peter's algorithm

On a bit level it looks like this:
  60   56   52   48   44   40   36   32   28   24   20   16   12    8    4    0
0    4    8    12   16   20   24   28   32   36   40   44   48   52   56   60   
KKKK KKKK KKKK KKKK KKKK KKKK CCCC CCCC OOOO OOOO OOOO OOSS SSVV VTTP PPPP PPPP

Bits:
    Key part:
    [40 - 63]	- K 
		- Key generated with the old HACK algorithm. Source of entropy
		  and used to 'encrypt' parts of the payload.
    Checksum:
    [32 - 39]   - C
		- Checksum - first two hex digits of the keyed sha1 hash of the 
                  payload with the key.
    Payload:
    [18 - 31]   - O
		- Options - Index of the actual option combination in the list
                  of all possible combinations for the product. Xored with the 
                  highest 14 bits of the key.
    [14 - 17]   - S
		- Socket (physical CPU) limit. Encoded as the index of the 
                  limit in the list of all possible socket limits. Xored with
                  the next highest 4 bit of the key.
    [11 - 13]	- V
		- Virt Limit - Limit of the number of virtual instances allowed.
                  Encoded as the index of the limit in the list of all possible 
                  virtualization limits. Xored with the next highest 3 bits of 
                  the key.
    [9 - 10]    - T
                - EN type - 0 => does not create Entitlement,
                            1 => creates Entitlement,
                            2 => installeronly. 
                  Not Xored.
    [0 - 8]	- P
                - Product code - 0 for Server and 1 for Client. Defines the 
                  format. Xored with the lowest 9 bits of the key.

24 digits:
    1  3  5  7  9  11 13 15 17 19 21 23
    KK KK KK KK KK CC CO OO OO SV TP PP
    
    32 digits:
    1  3  5  7  9  11 13 15 17 19 21 23 25 27 29 31
    KK KK KK KK KK KK KK CC CC OO OO OO OS SV TP PP
"""

# NOTE: the offsets are from the left -- deal with it
# toplevel key is length of IN string
formatMap = {
        #       field name  : (offset, length) in bits, that is
        16: {   IN_KEY      : (0, 24),
                IN_CHECKSUM : (24, 8),
                IN_OPTIONS  : (32, 14),
                IN_SOCKLIMIT: (46, 4),
                IN_VIRTLIMIT: (50, 3),
                IN_TYPE     : (53, 2),
                IN_PRODUCT  : (55, 9) },
        24: {   IN_KEY      : (0, 40),
                IN_CHECKSUM : (40, 12),
                IN_OPTIONS  : (52, 20),
                IN_SOCKLIMIT: (72, 4),
                IN_VIRTLIMIT: (76, 4),
                IN_TYPE     : (80, 4),
                IN_PRODUCT  : (84, 12) },
        32: {   IN_KEY      : (0, 56),
                IN_CHECKSUM : (56, 16),
                IN_OPTIONS  : (72, 24),
                IN_SOCKLIMIT: (96, 8),
                IN_VIRTLIMIT: (104, 4),
                IN_TYPE     : (108, 4),
                IN_PRODUCT  : (112, 16) } }

keyMap = {
        #       field name  : offset into key in bits (lengths from format map)
        16: {   IN_OPTIONS  : 0,
                IN_SOCKLIMIT: 14,
                IN_VIRTLIMIT: 18,
                IN_PRODUCT  : 15 },
        24: {   IN_OPTIONS  : 0,
                IN_SOCKLIMIT: 20,
                IN_VIRTLIMIT: 24,
                IN_PRODUCT  : 28 },
        32: {   IN_OPTIONS  : 0,
                IN_SOCKLIMIT: 24,
                IN_VIRTLIMIT: 32,
                IN_PRODUCT  : 40 } }

# not sure why I think this needs to go both ways
productMap = {  PROD_SERVER : 'server',
                PROD_CLIENT : 'client',
                PROD_RHGD   : 'rhgd',
                'server'    : PROD_SERVER,
                'client'    : PROD_CLIENT,
                'rhgd'      : PROD_RHGD }

optionsMap = {
	 PROD_SERVER : {
		0x1     : 'NoSLA',
		0x4     : 'Basic',
		0x8     : 'Standard',
		0x10    : 'Premium',
		0x20    : 'Devel',
		0x40    : 'Eval',
		0x80    : 'Level3',
		0x100   : 'FullProd',
		0x200   : 'Virt',
		0x400   : 'Cluster',
		0x800   : 'ClusterStorage',
		0x2000  : 'VirtPlatform',
		0x4000  : 'HPC',
		0x8000  : 'Directory',
		0x10000 : 'SMB' },
	 PROD_CLIENT : {
		0x1     : 'NoSLA',
		0x2     : 'Escalation',
		0x4     : 'Basic',
		0x8     : 'Standard',
		0x10    : 'Premium',
		0x20    : 'Devel',
		0x40    : 'Eval',
		0x80    : 'Level3',
		0x100   : 'FullProd',
                0x200   : 'Virt',
		0x1000  : 'Workstation',
		0x8000  : 'SMB',
                0x20000 : 'MultiMedia',
                0x40000 : 'DVD' },
	PROD_RHGD : {
		0x1     : 'NoSLA',
		0x2     : 'Escalation',
		0x4     : 'SysIntSup',
		0x80    : 'Level3',
		0x100   : 'FullProd',
		0x20000 : 'MultiMedia',
                0x40000 : 'DVD' } }

repoMap = {
        PROD_SERVER : {
                0x100   : ['Server'],
                0x200   : ['VT'],
                0x400   : ['Cluster'],
                0x800   : [0x400, 'ClusterStorage'],
                0x2000  : [0x200,0x800],
                0x4000  : [],
                0x8000  : [],
                0x10000 : [] },
        PROD_CLIENT : {
                0x100   : ['Client'],
                0x200   : ['VT'],
                0x1000  : ['Workstation'],
                0x8000  : [],
                0x20000 : ['MultiMedia'],
                0x40000 : ['DVD'] },
        PROD_RHGD : {
                0x100   : ['RedHat'],
                0x20000 : ['MultiMedia'],
                0x40000 : ['DVD'] } }

# types - Different kinds of entitlement numbers. 
#     installeronly - the entitlement number is used for the installer only.
#                     E.g. generated by a Satellite. 
#     entitlement   - Full entitlement number that can create an entitlement
#     preentitled   - Entitlement number given
typeMap = {
        PROD_SERVER : { 0x0 : "No Entitlement",
                        0x1 : "Entitlement",
                        0x2 : "Installer Only" },
        PROD_CLIENT : { 0x0 : "No Entitlement",
                        0x1 : "Entitlement",
                        0x2 : "Installer Only" },
        PROD_RHGD   : { 0x0 : "No Entitlement",
                        0x1 : "Entitlement",
                        0x2 : "Installer Only" } }
                        
# CPU configuration limits 0=unlimited
socklimitMap = {
        PROD_SERVER: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 
                        None, None, None, -1],
        PROD_CLIENT: [1, 2, 4, 8, 16, None, None, None, None, None, 
                        None, None, None, None, None, -1],
        PROD_RHGD  : [1, 2, None, None, None, None, None, None, None, None, 
                        None, None, None, None, None, -1] }

virtlimitMap = { 
        PROD_SERVER: [0, 4, 10, 128, None, None, None, -1],
        PROD_CLIENT: [0, 2, 4, 10, None, None, None, -1],
        PROD_RHGD  : [0, None, None, None, None, None, None, -1] }

# combinationsMap = all possible combinations of options the EN can encode
combinationsMap = {
     PROD_SERVER : {
        0 : 0x101, 1 : 0x301, 2 : 0x701, 3 : 0xb01, 4 : 0x4301, 5 : 0x8301, 6 : 0x10301, 7 : 0x4701, 
        8 : 0x8701, 9 : 0x10701, 10 : 0x18701, 11 : 0x4b01, 12 : 0x8b01, 13 : 0x10b01, 14 : 0x18b01, 15 : 0x18301, 
        16 : 0x501, 17 : 0x4501, 18 : 0x8501, 19 : 0x10501, 20 : 0x18501, 21 : 0x901, 22 : 0x4901, 23 : 0x8901, 
        24 : 0x10901, 25 : 0x18901, 26 : 0x4101, 27 : 0x8101, 28 : 0x10101, 29 : 0x18101, 30 : 0x2101, 31 : 0xa101, 
        32 : 0x12101, 33 : 0x1a101, 34 : 0x104, 35 : 0x304, 36 : 0x704, 37 : 0xb04, 38 : 0x4304, 39 : 0x8304, 
        40 : 0x10304, 41 : 0x4704, 42 : 0x8704, 43 : 0x10704, 44 : 0x18704, 45 : 0x4b04, 46 : 0x8b04, 47 : 0x10b04, 
        48 : 0x18b04, 49 : 0x18304, 50 : 0x504, 51 : 0x4504, 52 : 0x8504, 53 : 0x10504, 54 : 0x18504, 55 : 0x904, 
        56 : 0x4904, 57 : 0x8904, 58 : 0x10904, 59 : 0x18904, 60 : 0x4104, 61 : 0x8104, 62 : 0x10104, 63 : 0x18104, 
        64 : 0x2104, 65 : 0xa104, 66 : 0x12104, 67 : 0x1a104, 68 : 0x108, 69 : 0x308, 70 : 0x708, 71 : 0xb08, 
        72 : 0x4308, 73 : 0x8308, 74 : 0x10308, 75 : 0x4708, 76 : 0x8708, 77 : 0x10708, 78 : 0x18708, 79 : 0x4b08, 
        80 : 0x8b08, 81 : 0x10b08, 82 : 0x18b08, 83 : 0x18308, 84 : 0x508, 85 : 0x4508, 86 : 0x8508, 87 : 0x10508, 
        88 : 0x18508, 89 : 0x908, 90 : 0x4908, 91 : 0x8908, 92 : 0x10908, 93 : 0x18908, 94 : 0x4108, 95 : 0x8108, 
        96 : 0x10108, 97 : 0x18108, 98 : 0x2108, 99 : 0xa108, 100 : 0x12108, 101 : 0x1a108, 102 : 0x110, 103 : 0x310, 
        104 : 0x710, 105 : 0xb10, 106 : 0x4310, 107 : 0x8310, 108 : 0x10310, 109 : 0x4710, 110 : 0x8710, 111 : 0x10710, 
        112 : 0x18710, 113 : 0x4b10, 114 : 0x8b10, 115 : 0x10b10, 116 : 0x18b10, 117 : 0x18310, 118 : 0x510, 119 : 0x4510, 
        120 : 0x8510, 121 : 0x10510, 122 : 0x18510, 123 : 0x910, 124 : 0x4910, 125 : 0x8910, 126 : 0x10910, 127 : 0x18910, 
        128 : 0x4110, 129 : 0x8110, 130 : 0x10110, 131 : 0x18110, 132 : 0x2110, 133 : 0xa110, 134 : 0x12110, 135 : 0x1a110, 
        136 : 0x181, 137 : 0x381, 138 : 0x781, 139 : 0xb81, 140 : 0x4381, 141 : 0x8381, 142 : 0x10381, 143 : 0x4781, 
        144 : 0x8781, 145 : 0x10781, 146 : 0x18781, 147 : 0x4b81, 148 : 0x8b81, 149 : 0x10b81, 150 : 0x18b81, 151 : 0x18381, 
        152 : 0x581, 153 : 0x4581, 154 : 0x8581, 155 : 0x10581, 156 : 0x18581, 157 : 0x981, 158 : 0x4981, 159 : 0x8981, 
        160 : 0x10981, 161 : 0x18981, 162 : 0x4181, 163 : 0x8181, 164 : 0x10181, 165 : 0x18181, 166 : 0x2181, 167 : 0xa181, 
        168 : 0x12181, 169 : 0x1a181, 170 : 0x184, 171 : 0x384, 172 : 0x784, 173 : 0xb84, 174 : 0x4384, 175 : 0x8384, 
        176 : 0x10384, 177 : 0x4784, 178 : 0x8784, 179 : 0x10784, 180 : 0x18784, 181 : 0x4b84, 182 : 0x8b84, 183 : 0x10b84, 
        184 : 0x18b84, 185 : 0x18384, 186 : 0x584, 187 : 0x4584, 188 : 0x8584, 189 : 0x10584, 190 : 0x18584, 191 : 0x984, 
        192 : 0x4984, 193 : 0x8984, 194 : 0x10984, 195 : 0x18984, 196 : 0x4184, 197 : 0x8184, 198 : 0x10184, 199 : 0x18184, 
        200 : 0x2184, 201 : 0xa184, 202 : 0x12184, 203 : 0x1a184, 204 : 0x188, 205 : 0x388, 206 : 0x788, 207 : 0xb88, 
        208 : 0x4388, 209 : 0x8388, 210 : 0x10388, 211 : 0x4788, 212 : 0x8788, 213 : 0x10788, 214 : 0x18788, 215 : 0x4b88, 
        216 : 0x8b88, 217 : 0x10b88, 218 : 0x18b88, 219 : 0x18388, 220 : 0x588, 221 : 0x4588, 222 : 0x8588, 223 : 0x10588, 
        224 : 0x18588, 225 : 0x988, 226 : 0x4988, 227 : 0x8988, 228 : 0x10988, 229 : 0x18988, 230 : 0x4188, 231 : 0x8188, 
        232 : 0x10188, 233 : 0x18188, 234 : 0x2188, 235 : 0xa188, 236 : 0x12188, 237 : 0x1a188, 238 : 0x190, 239 : 0x390, 
        240 : 0x790, 241 : 0xb90, 242 : 0x4390, 243 : 0x8390, 244 : 0x10390, 245 : 0x4790, 246 : 0x8790, 247 : 0x10790, 
        248 : 0x18790, 249 : 0x4b90, 250 : 0x8b90, 251 : 0x10b90, 252 : 0x18b90, 253 : 0x18390, 254 : 0x590, 255 : 0x4590, 
        256 : 0x8590, 257 : 0x10590, 258 : 0x18590, 259 : 0x990, 260 : 0x4990, 261 : 0x8990, 262 : 0x10990, 263 : 0x18990, 
        264 : 0x4190, 265 : 0x8190, 266 : 0x10190, 267 : 0x18190, 268 : 0x2190, 269 : 0xa190, 270 : 0x12190, 271 : 0x1a190, 
        272 : 0x140, 273 : 0x340, 274 : 0x740, 275 : 0xb40, 276 : 0x4340, 277 : 0x8340, 278 : 0x10340, 279 : 0x4740, 
        280 : 0x8740, 281 : 0x10740, 282 : 0x18740, 283 : 0x4b40, 284 : 0x8b40, 285 : 0x10b40, 286 : 0x18b40, 287 : 0x18340, 
        288 : 0x540, 289 : 0x4540, 290 : 0x8540, 291 : 0x10540, 292 : 0x18540, 293 : 0x940, 294 : 0x4940, 295 : 0x8940, 
        296 : 0x10940, 297 : 0x18940, 298 : 0x4140, 299 : 0x8140, 300 : 0x10140, 301 : 0x18140, 302 : 0x2140, 303 : 0xa140, 
        304 : 0x12140, 305 : 0x1a140, 306 : 0x144, 307 : 0x344, 308 : 0x744, 309 : 0xb44, 310 : 0x4344, 311 : 0x8344, 
        312 : 0x10344, 313 : 0x4744, 314 : 0x8744, 315 : 0x10744, 316 : 0x18744, 317 : 0x4b44, 318 : 0x8b44, 319 : 0x10b44, 
        320 : 0x18b44, 321 : 0x18344, 322 : 0x544, 323 : 0x4544, 324 : 0x8544, 325 : 0x10544, 326 : 0x18544, 327 : 0x944, 
        328 : 0x4944, 329 : 0x8944, 330 : 0x10944, 331 : 0x18944, 332 : 0x4144, 333 : 0x8144, 334 : 0x10144, 335 : 0x18144, 
        336 : 0x2144, 337 : 0xa144, 338 : 0x12144, 339 : 0x1a144, 340 : 0x148, 341 : 0x348, 342 : 0x748, 343 : 0xb48, 
        344 : 0x4348, 345 : 0x8348, 346 : 0x10348, 347 : 0x4748, 348 : 0x8748, 349 : 0x10748, 350 : 0x18748, 351 : 0x4b48, 
        352 : 0x8b48, 353 : 0x10b48, 354 : 0x18b48, 355 : 0x18348, 356 : 0x548, 357 : 0x4548, 358 : 0x8548, 359 : 0x10548, 
        360 : 0x18548, 361 : 0x948, 362 : 0x4948, 363 : 0x8948, 364 : 0x10948, 365 : 0x18948, 366 : 0x4148, 367 : 0x8148, 
        368 : 0x10148, 369 : 0x18148, 370 : 0x2148, 371 : 0xa148, 372 : 0x12148, 373 : 0x1a148, 374 : 0x150, 375 : 0x350, 
        376 : 0x750, 377 : 0xb50, 378 : 0x4350, 379 : 0x8350, 380 : 0x10350, 381 : 0x4750, 382 : 0x8750, 383 : 0x10750, 
        384 : 0x18750, 385 : 0x4b50, 386 : 0x8b50, 387 : 0x10b50, 388 : 0x18b50, 389 : 0x18350, 390 : 0x550, 391 : 0x4550, 
        392 : 0x8550, 393 : 0x10550, 394 : 0x18550, 395 : 0x950, 396 : 0x4950, 397 : 0x8950, 398 : 0x10950, 399 : 0x18950, 
        400 : 0x4150, 401 : 0x8150, 402 : 0x10150, 403 : 0x18150, 404 : 0x2150, 405 : 0xa150, 406 : 0x12150, 407 : 0x1a150, 
        408 : 0x400, 409 : 0x800, 410 : 0x8000, 411 : 0x480, 412 : 0x880, 413 : 0x8080, 414 : 0x120, 
    },

PROD_CLIENT : {
        0 : 0x101, 1 : 0x301, 2 : 0x8101, 3 : 0x1101, 4 : 0x8301, 5 : 0x1301, 6 : 0x9301, 7 : 0x9101, 
        8 : 0x102, 9 : 0x302, 10 : 0x8102, 11 : 0x1102, 12 : 0x8302, 13 : 0x1302, 14 : 0x9302, 15 : 0x9102, 
        16 : 0x104, 17 : 0x304, 18 : 0x8104, 19 : 0x1104, 20 : 0x8304, 21 : 0x1304, 22 : 0x9304, 23 : 0x9104, 
        24 : 0x108, 25 : 0x308, 26 : 0x8108, 27 : 0x1108, 28 : 0x8308, 29 : 0x1308, 30 : 0x9308, 31 : 0x9108, 
        32 : 0x110, 33 : 0x310, 34 : 0x8110, 35 : 0x1110, 36 : 0x8310, 37 : 0x1310, 38 : 0x9310, 39 : 0x9110, 
        40 : 0x181, 41 : 0x381, 42 : 0x8181, 43 : 0x1181, 44 : 0x8381, 45 : 0x1381, 46 : 0x9381, 47 : 0x9181, 
        48 : 0x182, 49 : 0x382, 50 : 0x8182, 51 : 0x1182, 52 : 0x8382, 53 : 0x1382, 54 : 0x9382, 55 : 0x9182, 
        56 : 0x184, 57 : 0x384, 58 : 0x8184, 59 : 0x1184, 60 : 0x8384, 61 : 0x1384, 62 : 0x9384, 63 : 0x9184, 
        64 : 0x188, 65 : 0x388, 66 : 0x8188, 67 : 0x1188, 68 : 0x8388, 69 : 0x1388, 70 : 0x9388, 71 : 0x9188, 
        72 : 0x190, 73 : 0x390, 74 : 0x8190, 75 : 0x1190, 76 : 0x8390, 77 : 0x1390, 78 : 0x9390, 79 : 0x9190, 
        80 : 0x140, 81 : 0x340, 82 : 0x8140, 83 : 0x1140, 84 : 0x8340, 85 : 0x1340, 86 : 0x9340, 87 : 0x9140, 
        88 : 0x142, 89 : 0x342, 90 : 0x8142, 91 : 0x1142, 92 : 0x8342, 93 : 0x1342, 94 : 0x9342, 95 : 0x9142, 
        96 : 0x144, 97 : 0x344, 98 : 0x8144, 99 : 0x1144, 100 : 0x8344, 101 : 0x1344, 102 : 0x9344, 103 : 0x9144, 
        104 : 0x148, 105 : 0x348, 106 : 0x8148, 107 : 0x1148, 108 : 0x8348, 109 : 0x1348, 110 : 0x9348, 111 : 0x9148, 
        112 : 0x150, 113 : 0x350, 114 : 0x8150, 115 : 0x1150, 116 : 0x8350, 117 : 0x1350, 118 : 0x9350, 119 : 0x9150, 
        120 : 0x120, 121 : 0x20101, 122 : 0x20301, 123 : 0x28101, 124 : 0x21101, 125 : 0x28301, 126 : 0x21301, 127 : 0x29301, 
        128 : 0x29101, 129 : 0x20102, 130 : 0x20302, 131 : 0x28102, 132 : 0x21102, 133 : 0x28302, 134 : 0x21302, 135 : 0x29302, 
        136 : 0x29102, 137 : 0x20104, 138 : 0x20304, 139 : 0x28104, 140 : 0x21104, 141 : 0x28304, 142 : 0x21304, 143 : 0x29304, 
        144 : 0x29104, 145 : 0x20108, 146 : 0x20308, 147 : 0x28108, 148 : 0x21108, 149 : 0x28308, 150 : 0x21308, 151 : 0x29308, 
        152 : 0x29108, 153 : 0x20110, 154 : 0x20310, 155 : 0x28110, 156 : 0x21110, 157 : 0x28310, 158 : 0x21310, 159 : 0x29310, 
        160 : 0x29110, 161 : 0x20181, 162 : 0x20381, 163 : 0x28181, 164 : 0x21181, 165 : 0x28381, 166 : 0x21381, 167 : 0x29381, 
        168 : 0x29181, 169 : 0x20182, 170 : 0x20382, 171 : 0x28182, 172 : 0x21182, 173 : 0x28382, 174 : 0x21382, 175 : 0x29382, 
        176 : 0x29182, 177 : 0x20184, 178 : 0x20384, 179 : 0x28184, 180 : 0x21184, 181 : 0x28384, 182 : 0x21384, 183 : 0x29384, 
        184 : 0x29184, 185 : 0x20188, 186 : 0x20388, 187 : 0x28188, 188 : 0x21188, 189 : 0x28388, 190 : 0x21388, 191 : 0x29388, 
        192 : 0x29188, 193 : 0x20190, 194 : 0x20390, 195 : 0x28190, 196 : 0x21190, 197 : 0x28390, 198 : 0x21390, 199 : 0x29390, 
        200 : 0x29190, 201 : 0x20140, 202 : 0x20340, 203 : 0x28140, 204 : 0x21140, 205 : 0x28340, 206 : 0x21340, 207 : 0x29340, 
        208 : 0x29140, 209 : 0x20142, 210 : 0x20342, 211 : 0x28142, 212 : 0x21142, 213 : 0x28342, 214 : 0x21342, 215 : 0x29342, 
        216 : 0x29142, 217 : 0x20144, 218 : 0x20344, 219 : 0x28144, 220 : 0x21144, 221 : 0x28344, 222 : 0x21344, 223 : 0x29344, 
        224 : 0x29144, 225 : 0x20148, 226 : 0x20348, 227 : 0x28148, 228 : 0x21148, 229 : 0x28348, 230 : 0x21348, 231 : 0x29348, 
        232 : 0x29148, 233 : 0x20150, 234 : 0x20350, 235 : 0x28150, 236 : 0x21150, 237 : 0x28350, 238 : 0x21350, 239 : 0x29350, 
        240 : 0x29150, 241 : 0x20120, 242 : 0x60101, 243 : 0x60301, 244 : 0x68101, 245 : 0x61101, 246 : 0x68301, 247 : 0x61301, 
        248 : 0x69301, 249 : 0x69101, 250 : 0x60102, 251 : 0x60302, 252 : 0x68102, 253 : 0x61102, 254 : 0x68302, 255 : 0x61302, 
        256 : 0x69302, 257 : 0x69102, 258 : 0x60104, 259 : 0x60304, 260 : 0x68104, 261 : 0x61104, 262 : 0x68304, 263 : 0x61304, 
        264 : 0x69304, 265 : 0x69104, 266 : 0x60108, 267 : 0x60308, 268 : 0x68108, 269 : 0x61108, 270 : 0x68308, 271 : 0x61308, 
        272 : 0x69308, 273 : 0x69108, 274 : 0x60110, 275 : 0x60310, 276 : 0x68110, 277 : 0x61110, 278 : 0x68310, 279 : 0x61310, 
        280 : 0x69310, 281 : 0x69110, 282 : 0x60181, 283 : 0x60381, 284 : 0x68181, 285 : 0x61181, 286 : 0x68381, 287 : 0x61381, 
        288 : 0x69381, 289 : 0x69181, 290 : 0x60182, 291 : 0x60382, 292 : 0x68182, 293 : 0x61182, 294 : 0x68382, 295 : 0x61382, 
        296 : 0x69382, 297 : 0x69182, 298 : 0x60184, 299 : 0x60384, 300 : 0x68184, 301 : 0x61184, 302 : 0x68384, 303 : 0x61384, 
        304 : 0x69384, 305 : 0x69184, 306 : 0x60188, 307 : 0x60388, 308 : 0x68188, 309 : 0x61188, 310 : 0x68388, 311 : 0x61388, 
        312 : 0x69388, 313 : 0x69188, 314 : 0x60190, 315 : 0x60390, 316 : 0x68190, 317 : 0x61190, 318 : 0x68390, 319 : 0x61390, 
        320 : 0x69390, 321 : 0x69190, 322 : 0x60140, 323 : 0x60340, 324 : 0x68140, 325 : 0x61140, 326 : 0x68340, 327 : 0x61340, 
        328 : 0x69340, 329 : 0x69140, 330 : 0x60142, 331 : 0x60342, 332 : 0x68142, 333 : 0x61142, 334 : 0x68342, 335 : 0x61342, 
        336 : 0x69342, 337 : 0x69142, 338 : 0x60144, 339 : 0x60344, 340 : 0x68144, 341 : 0x61144, 342 : 0x68344, 343 : 0x61344, 
        344 : 0x69344, 345 : 0x69144, 346 : 0x60148, 347 : 0x60348, 348 : 0x68148, 349 : 0x61148, 350 : 0x68348, 351 : 0x61348, 
        352 : 0x69348, 353 : 0x69148, 354 : 0x60150, 355 : 0x60350, 356 : 0x68150, 357 : 0x61150, 358 : 0x68350, 359 : 0x61350, 
        360 : 0x69350, 361 : 0x69150, 362 : 0x60120,
    },
    
    PROD_RHGD : {
        0 : 0x101, 1 : 0x20101, 2 : 0x60101, 3 : 0x102, 4 : 0x20102, 5 : 0x60102, 6 : 0x182, 7 : 0x20182, 
        8 : 0x60182, 9 : 0x104, 10 : 0x20104, 11 : 0x60104, 12 : 0x184, 13 : 0x20184, 14 : 0x60184, 
    },

}

encodingMaps = {IN_OPTIONS       : optionsMap,
                IN_SOCKLIMIT     : socklimitMap,
                IN_VIRTLIMIT     : virtlimitMap,
                IN_TYPE          : typeMap,
                IN_PRODUCT       : productMap,
                IN_REPO          : repoMap,
                IN_COMBINATIONS  : combinationsMap }

def test_data_from_file(filename):
    buf = [l.strip() for l in open(filename)]

in_strings = [x[1] for x in enumerate(buf) if x[0] % 3 == 0]
    values = [x[1] for x in enumerate(buf) if x[0] % 3 == 2]

test_data = {}
    for k,v in zip(in_strings, values):
        (product, socklimit, virtlimit, opts_index, rest) = v.split(' ', 4)
        product = product.replace('rhel_', '')
        socklimit = int(socklimit)
        virtlimit = int(virtlimit)
        opts_index = int(opts_index)
        toks = rest.split()
        in_type = int(toks[-2])
        option_strings = eval(" ".join(toks[:-2]))

test_data[k] = (product, socklimit, virtlimit, opts_index, 
                        option_strings, in_type)

return test_data

def test_from_file(filename):
    test_data = test_data_from_file(filename)

num_pass = 0
    num_total = len(test_data.keys())

for in_string, in_data in test_data.items():
        rc = test(in_string, in_data)
        if rc:
            num_pass += 1

pct = int(float(num_pass)/float(num_total) * 100)
    print "%d%% (%d/%d) Passed" % (pct, num_pass, num_total)

def test(in_string, test_data):
    (tproduct, tsocklimit, tvirtlimit,
     topts_index, topt_strings, ttype) = test_data

inum = InstallationNumber(in_string)

product = inum.get_product_string()
    socklimit = inum.get_socklimit()
    virtlimit = inum.get_virtlimit()
    opts = inum.get_options()
    opt_strings = inum.get_options_string().split()
    in_type = inum.get_type()

err_str = "%s\n" % (in_string,)
    errors = 0

if product != tproduct:
        err_str += "  product: '%s' != '%s'\n" % (product, tproduct)
        errors += 1

if socklimit != tsocklimit:
        err_str += "  socklimit: %d != %d\n" % (socklimit, tsocklimit)
        errors += 1

if virtlimit != tvirtlimit:
        err_str += "  virtlimit: %d != %d\n" % (virtlimit, tvirtlimit)
        errors += 1

topts = encodingMaps[IN_COMBINATIONS][inum.get_product()][topts_index]
    if opts != topts:
        err_str += "  options: %x != %x\n" % (opts, topts)
        errors += 1

topt_strings.sort()
    opt_strings.sort()
    if opt_strings != topt_strings:
        err_str += "  options: %s != %s\n" % (opt_strings, topt_strings)
        errors += 1

if in_type != ttype:
        err_str += "  type: %d != %d\n" % (in_type, ttype)
        errors += 1

if errors:
        print err_str
    
    return errors == 0

if __name__ == "__main__":
    import sys
    import os

if len(sys.argv) < 2:
        sys.exit(1)

if os.access(sys.argv[1], os.R_OK):
        td = test_from_file(sys.argv[1])
        sys.exit(0)

in_string =  sys.argv[1]
    inum = InstallationNumber(in_string)

print inum.get_summary_string()

# return values of all the get_FOO and get_FOO_string methods
    for field in inum.formatMap.keys():
        name = fieldNamesMap[field]
        print "%s: %s '%s'" % (name,
                               eval('inum.get_' + name + '()'),
                               eval('inum.get_' + name + '_string()'))

print
    print inum.get_repos_dict()

print
    print inum

"""
    # this format is intended to ease visual comparison with the POC output
    print "%s %s %s %s [%s] %s" % (inum.get_product_string(),
                                   inum.get_socklimit(),
                                   inum.get_virtlimit(),
                                   inum.getRaw(IN_OPTIONS),
                                   inum.get_options_string(),
                                   inum.get_type())

print
    """