as United States
`a2) Patent Application Publication co) Pub. No.: US 2003/0014381 Al
`(43) Pub. Date: Jan. 16, 2003
`
`MCMILLANetal.
`
`US 20030014381A1
`
`(54) METHOD AND SYSTEM FOR IDENTIFYING
`AND RESOLVING SOFTWARE CONFLICTS
`AND COMPUTER-READABLE STORAGE
`MEDIUM HAVING A PROGRAM FOR
`EXECUTING THE METHOD
`
`(76)
`
`Inventors: JOHN J. MCMILLAN, MILFORD,
`MI (US); GARY D. CHIRHART,
`ROCHESTER HILLS, MI (US)
`
`Correspondence Address:
`JOHN G. POSA, ESQ.
`GIFFORD KRASS GROH SPRINKLE
`ANDERSON & CITKOWSKI
`280 N. OLD WOODWARD AVENUE
`SUITE 400
`BIRMINGHAM,MI 48009 (US)
`
`(*) Notice:
`
`This is a publication of a continued pros-
`ecution application (CPA) filed under 37
`CER 1.53(d).
`
`(21) Appl. No.:
`
`09/189,559
`
`(22)
`
`Filed:
`
`Nov. 11, 1998
`
`Publication Classification
`
`(52) US. Che
`
`cescssessssnssssinstnstntsesnesstsesstsstsnssenee 707/1
`
`(57)
`
`ABSTRACT
`
`Method and system for managing software conflicts and a
`computer-readable storage medium having a program for
`executing the method is provided wherein a database of
`interrelated tables is utilized. The invention may be used to
`managefile and registry conflicts on Windowsdesktops. The
`invention determines information about changes made by
`applications during their installation into a computer system,
`one application at a time. ‘Those changes are then compared
`to determine whichfiles and other shared resources conflict
`with one another. This conflict information is then used to
`attempt to resolve software conflicts. Conflicts can be iden-
`tified at many different levels: files, registries, shortcuts,
`ODBC drivers, ODBC data sources, service, device, com-
`ponents, autoexec.bat, contig.sys, INI changes, and paths.
`This invention stores all information needed to recreate the
`installation in the database itself. Thus, when changes (i.e.
`when conflicts between multiple applications are being
`resolved) are madeto the database, a neededinstaller for that
`application can be generated. The database categorizes all
`file types and breaks the information down into manageable
`tables of information. These tables relate to each other in an
`
`(51) Unt, CI aiceccccsssssssssistsstnesssieentasses GO6F 7/00
`
`intricate web that allows a thorough illustration offiles.
`
`
`
`Google Exhibit 1026
`Google v. VirtaMove
`
`Google Exhibit 1026
`Google v. VirtaMove
`
`

`

`Patent Application Publication
`
`Jan. 16, 2003 Sheet 1 of 5
`
`US 2003/0014381 Al
`
`oaeesyl YP
`cA
`LaerPIs
`J
`CA OR PIO
`
`
`Bey
`cS
`EIAPEREDEy
`
`=~
`EES
`
`
`14
`
` RUNNING
`
`ALL APPS
`
`
`NO
`
`26
`
` ALL
`FILES FOR
`SINGLE APP
`
`
`
`NO
`
`YES
`
`16
`
`YES
`
`DELETE RECORDS
`FROM CONFLICT TABLE
`
`SEE FIG. 3
`
`18
`
`
`42
`
`
`SINGLE
`
`RECORD - DID THIS
`
`RECORD CONFLICT
`
`PREVIOUSLY?
`
`
`YES
`
`SEE FIG. 4
`
`24
`
`
`
`FOR EACH PAIR OF
`RECORDS THAT MATCH
`
`
`THE JOIN CRITERIA,
`
`
`DETERMINE NEW ERROR
`
`
`LEVEL
`
`
`
`
`
`SEE FIG. 5
`
`FIND ALL RECORDS
`MATCHING JOIN CRITERIA
`
`
`
`SET CONFLICT LEVEL TO
`ZERO FOR ALL RECORDS
`IN FILE TABLE
`
`MARK APPS -
`CONFLICT NOT RUN
`
`20
`
`;
`
`

`

`Patent Application Publication
`
`Jan. 16,2003 Sheet 2 of 5
`
`US 2003/0014381 Al
`
`14
`
`
` NO
`RUNNING
`ALL APPS
`
`
`YES
`
`26
`
`
`ALL
`
`FILES FOR
`SINGLE APP
`
`
`
`NO
`
`YES
`
`42
`
`
`
`SINGLE
`
`
`RECORD - DID THIS
`RECORD CONFLICT
`PREVIOUSLY?
`
`
`
`
`
`YES
`
`SEE FIG. 4
`
`{
`
`SEE FIG. 2
`
`)
`
`FILES IN THIS APP.
`
`FIND ALL FILES IN OTHER
`APPS THAT CONFLICT WITH
`
`MARK ERROR LEVEL FOR
`ALL ABOVE FILES AS LEVEL 0
`
`28
`
`30
`
`DELETE RECORDS FROM
`CONFLICT TABLE FOR
`THIS APP
`
`30
`
`SY. F
`F-
`
`FEROFORALL RECORDS
`IN THIS APP
`
`34
`
`
`MARK APP -
`CONFLICT NOT RUN
`
`FIND ALL RECORDS
`MATCHING JOIN CRITERIA
`FOR THIS APP
`
`FOR EACH PAIR OF RECORDS
`THAT MATCH THE JOIN
`CRITERIA, DETERMINE
`NEW ERROR LEVEL
`
`SEE FIG. 5
`
`36
`
`238
`
`40
`
`

`

`Patent Application Publication
`
`Jan. 16,2003 Sheet 3 of 5
`
`US 2003/0014381 Al
`
`NO
`
`
` RUNNING
`40
`ALL APPS
`
` SINGLEitt
`
`
`
`
`PREVIOUSLY?
`SINGLE APE
`
`
`
`
`YES
`26
`
`
`
`SEE FIG. 2
`
`SEE FIG. 3
`
`YES
`
`56
`
`
`WAS IT
`
`INFORMATIONAL &
`
`YES
`
`QUERY RECORDS THAT
`MATCH OLD RECORD
`
`MARK ERROR LEVEL FOR
`THIS RECORD AS ZERO
`
`FIND OTHER CONFLICTING
`
`ea
`LEVEL AS ZERO
`
`FY. F
`
`44
`
`:
`
`48
`
`DID IT CHANGE
`NEW ERROR LEVEL
`
`
`MARKTHOSERECORDS
`
`
`50
`
`NUMBER
`OF MATCHES 10
`
`OLD RECORD
`
`
`
`
`
`MARK ERROR LEVEL
`FOR RECORD AS
`NO CONFLICT
`
`| DELETE RECORDS FOR THIS
`FILE FROM CONFLICT TABLE
`
`62
`
`FIND ALL RECORDS
`MATCHING JOIN CRITERIA
`TO THIS RECORD
`
`FOR EACH PAIR OF RECORDS
`THAT MATCH THE JOIN
`CRITERIA, DETERMINE
`
`
`MARK ERROR LEVEL FOR
`
`RECORD AS INFORMATIONAL
`
`
`
`
`
`SEE FIG. 5
`
`

`

`Patent Application Publication
`
`Jan. 16,2003 Sheet 4 of 5
`
`US 2003/0014381 Al
`
`FOR EACH PAIR OF RECORDS THAT
`MATCH THE JOIN CRITERIA,
`
`"OR" THIS LEVEL WITH ANY PREVIOUS
`ERRORS STORED FOR THIS RECORD
`
`68
`
`DETERMINE NEW ERROR LEVEL
`
`
`
`
`
` SHOW ERROR IN
`RECORDS?
`CONFLICT TABLE
`MORE CONFLICT
`INFORMATIONAL
`ERROR?
`
`
`
`FD: a
`
`FOR EACH RECORD THAT
`HAS BEEN STORED
`
`74
`
`76
`
`
`1S RECORD
`
`IN THIS APP OR
`
`
`FINDING CONFLICTS
`
`FOR ALL APPS
`
` YES
`
`
`
`IF CURRENT RECORDIS
`WAS THIS
`
`INFORMATIONAL KEEP AS
`RECORD MARKED
`
`INFORMATIONAL
`AS AFFECTED
`
`
`NO
`
`FIND CONFLICTS BETWEEN
`OTHER APPS FOR THIS
`RECORD AND “OR" TOGETHER
`
`
`
`
`73
`
`
`
`86
`
`
`
`
`
`
`
` MARK Weir AS
`
`
`SAVE RECORD WITH
`NEW ERROR LEVEL
`
`
`MORE
`
`STORED
`
`RECORDS?
`
`HAVING CONFLICTS RUN
`
`

`

`Patent Application Publication
`
`06
`
`7uonearddyc6
`
`oesglee)Cowte
`
`ledPPY
`
`Aysibey
`
`(~
`
`INQVOYS
`
`02}colStl
`
`86
`
`901
`
`96
`
`Jan. 16, 2003 Sheet 5 of 5
`
`US 2003/0014381 Al
`
`
`
`
`
`Ov!juauodwo9ISWnyogao9ét
`
`cel
`
`0éL
`
`Maggqdopel
`
`9tt
`
`dewddyus
`
`Phi
`
`
`
`chtjolyuogua’y
`
`yoju0gggao8Et
`
`91961vel
`
`jajUogelly
`
`chk
`
`deyyddyalt4
`
`OL!
`
`Buuisall4—_
`
`901
`
`
`
`
`
`

`

`US 2003/0014381 Al
`
`Jan. 16, 2003
`
`METHOD AND SYSTEM FOR IDENTIFYING AND
`RESOLVING SOFTWARE CONFLICTS AND
`COMPUTER-READABLE STORAGE MEDIUM
`HAVING A PROGRAM FOR EXECUTING THE
`METHOD
`
`time the file was modified can be used to indicate the version
`of the file. In addition, manyfiles include one or more
`internal version numbers. Problems occur when the different
`
`version numbersfor a file are in error or disagree with each
`other.
`
`TECHNICAL FIELD
`
`[0001] This invention relates to methods and systems for
`managing software conflicts and computer-readable storage
`medium having a program for executing the method and,in
`particular, to methods and systems for managing software
`conflicts and computer-readable storage medium having a
`program for executing the method utilizing a database of
`interrelated tables.
`
`BACKGROUND ART
`
`[0002] With the powerof today’s application development
`tools, a developer can create a custom application more
`quickly than ever. However, there is a significant hurdle
`getting those applications to the desktop due to file and other
`shared resource conflicts.
`
`[0003] Software conflicts oftentimes arise when multiple
`software applications modify a shared resource such as a
`file, registry key, or icon that is being used by another
`application that is installed on the same computer.
`
`[0004] Anyone managing the distribution of applications
`to users has very likely experienced what is commonly
`referred to as “DLL Hell.” Simply put, DLL hell occurs
`when one program disables others by installing an incom-
`patible dynamic link library, or DLL, file. This corrupts
`one’s system in one of two ways.In the first instance, an
`application installs an older DLL over a newer one. The
`second instance occurs when a newer DLLis properly
`installed but an application won’t work with the new ver-
`sion. In addition, other non-file system resources suchas the
`registry,
`icons, or system services may be replaced with
`incompatible versions.
`
`Independent software vendors distribute the DLLs
`[0005]
`and other support files they’ve tested during development.
`However, newer support files that already exist on the
`destination computer may already have superseded these by
`the time users load them.
`
`In theory, a vendor’s installation routine should
`[0006]
`double-check to see if a newer version of a shared DLL is
`already on the target system. Yet vendors have been sloppy
`or overly cautious about this. On the sloppy side of the
`equation, some installation routines simply don’t check for
`existing DLLs. In the interest of caution,
`though, some
`vendors intend to copy the specific DLL that they’ve tested,
`which gives them some cause for confidence. Copying older
`DLL versions means the newly installed application will
`work,but applications that rely on later versions of the DLL
`are now more likely to encounter problems.
`
`[0007] Even if the newerversion of the shared component
`copies over alder versions there can be problems. It is not
`always the case that an updated version of a shared com-
`ponent will be completely backward compatible.
`
`[0009] The file system namespace readily allows colli-
`sions. Vendors currently tend to throw manyof their support
`files into a common directory such as the System directory.
`Further, even though Microsoft’s 32-bit OSes allow long
`filenames, most vendors stick to the 8.3 convention; they
`must if their DLLs are also for 16-bit environments. Plus,
`their files may someday reside on a shared network drive
`that supports only short names.
`
`[0010] There are only so many eight-character names—
`fewer when you use meaningful abbreviations and short
`words. When two developers use a name like DISPLAY-
`-DLL, conflicts occur.
`
`{0011] End users are often unaware that underlying sys-
`tem-level components have changed. Loading something
`like an Internet Explorer browser update can update low-
`level OS components—the lowest-level TCP/IP protocol
`stack DLLs, for example. There maybe no direct relation;
`Microsoft may have used the update to slipstream a number
`of OS patches.
`
`[0012] The result is that it becomes harder for vendors to
`support their products because it is difficult to tell exactly
`what set of system DLLs any given user has. Developers
`dislike working in the Microsoft environment right now
`describing it as a “snake pit” from a support standpoint
`because they don’t know what their customers have.
`
`[0013] This problem has been very difficult to prevent and
`identify until it is too late, resulting in system failures and
`significant user downtime. DLLs represent only one of
`severalfile conflicts that may occur. Conflicts can also occur
`at different levels in registry keys, components, paths, and
`drivers making the problemall the more complex.
`
`there is a need for an improved
`[0014] Accordingly,
`method of identifying and resolvingfile, registry and other
`shared componentconflicts between multiple applications.
`
`to Kullick et al. 5,764,992
`{0015] The U.S. Pat. No.
`provides for a method and apparatus for automatic software
`replacement. An automated software upgrade method is
`described which allows a software program to determine if
`it and its associated programsare the newest versions and to
`replace themselves if necessary.
`
`to Gerken et al. 5,787,444
`[0016] The U.S. Pat. No.
`provides for a method and apparatus for maintaining revi-
`sion control of a set of objects within a data processing
`system. In the context of software revision control, an object
`oriented method of maintaining control of hierarchically
`linked data is described.
`
`to Alderson et al. 5,019,963
`[0017] The US. Pat. No.
`provides for a data processing network with upgrading of
`files. A central host is described which maintainsa list of
`files accessible by a remote client and provides the most
`current version whena client so requests.
`
`In addition, the version information associated with
`[0008]
`sharedfiles is not always accurate. In many cases, there are
`multiple indications of the version of a file. The last date/
`
`to Holmes et al. 5,247,683
`[0018] The US. Pat. No.
`provides for asystem and methodfor installing software and
`updating configuration files. A method of maintaining a
`
`

`

`US 2003/0014381 Al
`
`Jan. 16, 2003
`
`system’s configurationfile is described which automatically
`determines how to update an existing configuration file to
`accommodate a new application.
`
`to Halliwell et al. 5,564,051
`[0019] The U.S. Pat. No.
`provides for an automatic update of static and dynamic files
`at a remote network node in response to calls issued by or
`for application programs. An application management sys-
`tem is described which identifies and replaces out-of-date
`files and augments or creates files which are needed.
`
`[0020] The U.S. Pat. No. to Fitzgerald et al. 5,581,764
`discloses a distributed computer network including hierar-
`chical resource information structure and a related method
`
`of distributing resources.
`
`{0021] The following U.S. Pat. Nos. are also relevant:
`4,558,413 to Schmidt et al.; 4,809,170 to Leblang et al.;
`5,155,847 to Kirouac et al; 5,574,898 to Leblang et al.; and
`5,603,027 to Ohkami.
`
`DISCLOSURE OF INVENTION
`
`[0022] An object of the present invention is to provide a
`method and system for managing software conflicts and
`computer-readable storage medium having a program for
`executing the method wherein a database of interrelated
`tables is utilized.
`
`[0023] Another object of the present invention is to pro-
`vide a method and system for managing software conflicts
`and computer-readable storage medium having a program
`for executing the method wherein conflicts are identified
`before software applications are introduced to a computer
`system,
`thus improving user productivity by eliminating
`system outages and downtime.
`
`In carrying out the above objects and other objects
`[0024]
`of the present invention, a method is provided for managing
`software conflicts. The method includes the step of deter-
`mining changes made to a computer system’s files and other
`shared resources during installation of at least one applica-
`tion into the computer system to obtain change information.
`The method includes the step of processing the change
`information to determine which files and shared resources
`conflict with one another to obtain conflict information. The
`method also includes the steps of storing the conflict infor-
`mation in a database of interrelated tables and resolving the
`software conflicts based on the stored conflict information.
`
`[0025] Further in carrying out the above objects and other
`objects of the present invention, a computer-readable stor-
`age medium having stored therein a program is provided.
`The program executes the above-noted method steps.
`
`[0026] Yet still further in carrying out the above objects
`and other objects of the present invention, a system is
`provided for managing software conflicts in accordance with
`the above-noted method steps.
`
`[0027] The software conflicts may include file conflicts,
`registry conflicts, shortcut conflicts, ODBC driver conflicts,
`ODBC data source conflicts, service conflicts, device con-
`flicts, componentconflicts, autoexec.bat conflicts, config.sys
`conflicts, INI changes conflicts, and path conflicts.
`
`rolled out onto their desktops. This saves an organization
`valuable support staff time. It avoids user downtime, and
`reduces regression testing to those applications that have
`identified conflicts.
`
`[0029] The above objects and other objects, features, and
`advantages of the present
`invention are readily apparent
`from the following detailed description of the best mode for
`carrying out the invention when taken in connection with the
`accompanying drawings.
`
`BRIEF DESCRIPTION OF DRAWINGS
`
`[0030] FIG. 1 is a schematic view of a computer system
`including a computer-readable storage medium configured
`with data which the computer system operates on to carry
`out the method of the present invention;
`
`FIG.2 is a block diagram flow chart which illus-
`[0031]
`trates an algorithm for determining conflicts on applications
`running on the computer system of FIG. 1;
`
`FIG.3 is a block diagram flow chart which illus-
`[0032]
`trates an algorithm for determining conflicts on files for a
`single application;
`
`[0033] FIG. 4 is a block diagram flow chart which illus-
`trates an algorithm for determining conflicts for a single
`record in a single application;
`
`FIG.5 is a block diagram flow chart which illus-
`[0034]
`trates an algorithm for analyzing the conflicts determined as
`a result of using the algorithms of FIGS. 2-4; and
`
`[0035] FIG. 6 is a block diagram of the tables of a
`database of the present invention illustrating table lay out
`and relationships.
`
`BEST MODE FOR CARRYING OUT THE
`INVENTION
`
`there is illustrated a
`[0036] Referring now to FIG. 1,
`computer system, generally indicated at 10, which, when
`appropriately programmed with computer-readable data
`encoded in a computer-readable storage medium such as a
`floppy disk 12, is capable of carrying out the method of the
`present invention. In general, the present invention is used to
`import, export, and analyze the changes made by an appli-
`cation to a computer system during its installation.
`In
`addition, it is used to compare software applications and
`determine whichfiles and shared resources conflict with one
`another. This conflict informationis fed into a database that
`is then used to attempt to resolve software conflicts. The
`database categorizes all system changes and breaks the
`information down into manageable tables of information.
`These tables relate to each other in an intricate web that
`
`allows a thoroughillustration of all the changes.
`
`[0037] Conflicts can be determined by several methods
`depending on need. The processis different between running
`conflicts for all applications (FIG.2), for a single applica-
`tion (FIG.3), or for a single file in a single application (FIG.
`4). The first step for cach variation is to clear old conflicts
`that exist for the application(s) or item that conflicts that
`existed for the application(s) or item that conflicts are to be
`run on. Then the newconflicts are found and stored. Errors
`
`[0028] The benefits accruing to the use of the present
`invention are numerous. For example, the customer benefits
`because conflicts are identificd before the applications are
`
`and warnings are stored in a conflict table that is associated
`with the particular item. Informational conflicts are only
`kept with the item that
`the conflict occurred for. For
`
`

`

`US 2003/0014381 Al
`
`Jan. 16, 2003
`
`example, a file with an informational conflict and an error
`will have one record in a FileConflict table representing the
`error and will have its own conflict level representing the
`error and the informational.
`
`[0038] Referring now to FIG.2, at block 14,the algorithm
`tests to determine if conflicts across all applications at one
`time is to be utilized.
`
`[0039] At block 16,thefirst step is to delete all record of
`previous conflicts. The application deletes the records from
`the conflict tables corresponding to the type of conflicts
`being run. Forfile conflicts, all items from the FileConflict
`table are deleted.
`
`[0040] Atblock 18, the application sets the individualitem
`records’ conflict level to zero. Forfiles, the Conflict column
`in the Files table is set to zero for all files.
`
`[0041] At block 20, conflicts are marked which have not
`been run for all applications since, at this point, all traces of
`conflicts have been deleted and conflicts would need to be
`
`rerun if interrupted. This step is done so the user will know
`what state an applicationis in.
`
`[0042] At block 22, all records matching a conflict join
`criteria are found. This step gathers records that are similar
`enough to possibly conflict. Only system resources of dif-
`ferent applications are compared. Forfiles, all files of the
`same destination filename are gathered and analyzed to
`determine the new conflicts beginning at block 24. Only files
`that are executable or reside in commondirectories such as
`Windows, Program Files, and System are compared.
`
`[0043] When running conflicts for a single application
`(FIG. 3), the process result is the same but the steps are
`different.
`
`[0044] At block 28, all records are found in other appli-
`cations that currently conflict with files in this application.
`This is done using the current records in the FileConflict
`table that contain this application.
`
`[0045] For each record that previously conflicted with files
`in this application, the record key is stored andits current
`error level is set to zero, as indicated at block 30. Records
`are temporarily stored throughout the process and written at
`the end. Duringlatersteps, these error levels are modified to
`contain the ORed valuesofall conflicts that occur.
`
`the records are deleted from the
`[0046] At block 32,
`conflict table for this application and at block 34 the indi-
`vidual item records conflict
`level
`is set to zero for this
`application. Forfiles, the conflict column in the Files table
`is set to zero for all files in this application.
`
`Finally, at block 36, conflicts are marked which
`[0047]
`have not been run for this application since all traces of
`conflicts for this application have been deleted. This step is
`done so the user will know what state an application is in.
`
`[0048] At block 38 all records matching the conflict join
`criteria are found for records against records in this appli-
`cation. This stcp gathers records that are similar cnough to
`possibly conflict. For files, all files of the same destination
`filename asfiles in this application are gathered in this step
`and then analyzed beginning at block 40.
`
`[0049] Referring now to FIG.4, at block 42 it is deter-
`mined whether to run conflicts for a single record that has
`been changed.
`It is first determined whether this record
`conflicted with other records before the change.
`
`[0050] At block 44, the previous conflict level is deter-
`mined by looking at the current value of the conflict column
`for the record. If the record used to conflict before it was
`
`changed,at block 44 it is determined if it was an informa-
`tional conflict and if it changed items that would makeit no
`longer an informational conflict with the samerecordsit had
`beenprior to being changed.
`the records are queried that
`[0051]
`If so, at block 46,
`previously were informational conflicts with this one by
`finding all records that match the old data.
`
`[0052] Each of these records is then stored as being
`affected by an informational conflict change at block 48.
`This distinction will be used to later determine whether
`
`informational conflicts were completed for the records.
`[0053] Depending on the numberof records that match the
`old record, as determined at block 50, different error levels
`are recorded for these records.
`
`[0054] At block 54,if only one matchesit, the error level
`is Zero.
`
`[0055] At block 52, if more than one record matches, they
`are eachstill informational conflicts with each other and the
`error level is set to informational.
`
`[0056] At block 56, this records key is stored andsets its
`current error level to 0 since all conflicts are recomputed for
`this record.
`
`[0057] At block 58, each record that previously conflicted
`with this record is stoked and its current error level is set to
`0. These are the records that were either errors or warnings
`with this record previously. For files,
`these are records
`referenced in the FileConflict table for this particularfile.
`[0058] At block 60, records for this file are deleted from
`the FileConflict table.
`
`[0059] Tinally, at block 62, all records matching the con-
`flict join criteria are found for records against this record.
`This step gathers records that are similar enough to possibly
`conflict.
`
`Forfiles, all files of the same destination filename
`[0060]
`as this file are gathered and then analyzed beginning at block
`64.
`
`[0061] The beginning ofthe process to determine the new
`conflicts begins at blocks 22, 38 and 62 when records that
`could be conflicts are found by matchingjoin criteria for all
`files, files of a single application, or a singlefile.
`[0062] Referring nowto FIG.5, at blocks 24, 40, 64 (ie.
`from FIGS. 2, 3, and 4, respectively), the conflict level
`between each pair of records that match the join criteria is
`determined based on other columnsin the records. Forfiles,
`the error level is set to informationalinitially. If the version,
`internal version, date/time, or size don’t match, and the
`destination directories match or both files are 16 bit
`executables, the error level is set to error, otherwise the error
`level is set to warning.
`
`[0063] At block 66, the error levels from the pair records
`that conflict are ORed with any stored error levels from
`previous steps for those records’ keys.
`
`

`

`US 2003/0014381 Al
`
`Jan. 16, 2003
`
`In general, most tables in the database utilize a
`[0071]
`conflict field. Entries that are found to conflict require a
`conflict level indicator in the conflict field. The indicator
`displays the severity of the conflict. A value of “0” indicates
`that no conflict was found. A value of “1” is informational
`(same item exists for another application, default if the
`match criteria are met), but Warning and Error Criteria are
`not met. A value of “2” is a Warning.
`It could cause
`problems, but not necessarily severe errors. A value of “4”
`indicates a Severe Error. This error could cause application
`malfunction.
`
`[0072] Conflicts between Microsoft Windows Installer
`components are also tracked. There is a MSIComponent
`table which contains component
`information from a
`Microsoft WindowsInstaller database for an install. Also,
`there is an MSIComponent column in the file, registry,
`ODBCServ, Shortcut, Service, and INIChange tables which
`is used to determine the component for each of these
`resources. MSIComponent conflicts occur when identical
`resources from the above tables are installed using different
`component GUIDs.
`
`[0073] An Application table 92 supplies each application
`with a unique number, knownas a key, so that the applica-
`tion maybeeasily identified in other tables. A Package table
`94,
`the Application table’s only child, gets its AppKey
`information from this table 92. The Package table 94 iden-
`tifies the version of the Application to be compared. All
`children of the Package table 94 use information supplied by
`the Application table 92 to identify which data goes with
`what application.
`
`[0074] The purpose of the Application table 92 is to supply
`each application with a unique number, knownas a key, so
`that the application may be easily identified in other tables.
`Each field of the Application table 92 performs a unique
`function. They are listed in Table 1.
`
`TABLE1
`
`Data Type
`
`Details
`
`Example
`
`Integer
`
`1
`Provides a unique number, also
`knownas a key, for each application. 3
`This key is used to identify the
`application in other tables. Any
`application can be assigned any
`number so long as the number is
`unique within this table.
`This is a text field that allows you to
`describe the applications to be
`compared.
`
`(1) Office 97
`(3) WordPerfect
`
`[0064] At block 68, it is determinedif the error level is an
`error or warning.
`
`[0065] At block 70, the error in the conflict table is saved.
`Forfiles, each records’ keys are written to the FileConflict
`table along with the corresponding error level between the
`two records. This process is repeated for each pair of files
`found that meet the join criteria as indicated at block 72.
`
`[0066] Blocks 76 through 86, for each record that has been
`stored as indicated at block 74, deal with the stored error
`levels that have been ORed together in previoussteps.If the
`stored record is not for this application when computing
`conflicts for a single application or record, at block 78,
`conflicts for this record are found against records in appli-
`cations other than the onc running conflicts for. These other
`conflict
`levels are ORed together with any stored error
`levels. These conflicts are found using conflicts with other
`records in the FileConflict table that match records for other
`applications.
`
`If this record was not marked as affected at block
`[0067]
`48, al block 82 the record is recorded to see if it has other
`informational conflicts by reading the current error level of
`that record. If so, then the error level is ORed with a one. If
`the record was markedas affected, the algorithm computes
`informational conflicts for the record at block 24, 40, 64.
`
`[0068] At block 84, the new error level for the record is
`written to the database. After all stored records have been
`processed,
`the application(s) are marked as having had
`conflicts run.
`
`[0069] The above process is repeated for all item types
`other than files stored in the database. The only difference is
`how conflicts are actually determined and which table they
`are stored in. To determine conflicts for registry records, the
`join criteria is the registry path and key name columns. An
`error occurs if the first 255 characters of the value,
`the
`
`Field
`
`AppKey
`(pk)
`
`Application
`
`50 Characters
`
`datatype, or the operation is different between a pair of
`records that have the same registry path and key name.
`ODBC drivers are joined by the driver name and whether
`they are 16 or 32 bit drivers. After the match is made, each
`attribute of the driver is compared.If an attribute exists for
`one driver and not the other, it is recorded as a warning.If
`two attributes exist, but have different values,
`those
`attributes are marked as errors.
`
`[0070] Referring now to FIG.6, there is illustrated the
`overall table layout and relationships of a database, gener-
`ally indicated at 90, that is utilized in the above process. The
`following information is providedto illustrate howthe tables
`relate to cach other.
`
`[0075] The Package table 94 is the only child of the
`Application table 92, and in turn, is a parent to mast of the
`othertables.It lists the package information for each com-
`pared application to be used as key data for its children.
`Where the Application table 92 allows one to assign a key
`number to each application to be compared,
`the Package
`table 94 allows one to assign a key to each version of an
`application. A package can only exist here if it belongs to
`one of the applications listed in the Application table 92.
`
`[0076] A package is a sub-unit of an application. There
`may be no or several packages within an application. Table
`2 indicates Package table ficlds.
`
`

`

`US 2003/0014381 Al
`
`Jan. 16, 2003
`
`Example
`1 Office 97
`3 WordPerfect
`
`1 Microsoft Word
`3.0
`2 Microsoft Word
`4.0
`Pi, CorelWPSte
`Office 97
`C.\Scripts\Office97.
`wse
`0,1
`
`Microsoft
`Reference, Tools
`% MAINDIR%\
`Office97\
`INSTALL.LOG
`
`1031
`1055
`
`Field
`
`AppKey
`(pk)
`
`Data Type
`
`Integer
`
`PackKey
`(pk)
`
`Integer
`
`Package
`Maindir
`ScriptLoc
`
`50 Characters
`255 Characters
`255 Characters
`
`Progfiles
`
`Long Integer
`
`IGroup
`
`50 Characters
`
`TABLE 2
`
`Details
`
`Each application to be compared has a
`unique number. This numberis the
`Application Key (AppKey)andis
`used to identify this application to all
`other tables that require an AppKey
`input. This table uses the AppKey
`information as its parent identifier.
`‘lhe PackKey indicates the version of
`the application. Different versions of
`the same application may be compared
`for conflicts.
`This is the text name of the package.
`This is the package’s main installation
`Original Wise script location for this
`package
`If the file is installed under the
`Program Files folder, there will be an
`indication of 1 in this field. One being
`the “true” indication, 0 being the
`“false” indication.
`Icon Group Name
`
`Logfile
`
`255 Characters
`
`ItemMask
`
`Long Integer
`
`The directory and nameofa file
`generated during the packages
`installation. ‘Vhis file is commonly
`used during the package’s
`uninstallation procedure.
`This field is a series of bit masks,
`with up to 32 different masks
`possible. Items in this field may be
`combined.
`
`
`[0077] An AutoExec table 96 is a child of the Package
`table 94. Its function is to house detailed information about
`the changes made to the Autoexec.bat. For an entry to exist
`in this table 96, it must first belong to a package (located in
`the Package table 94). It
`is from this package that
`the
`AppKey and PackKey information is obtained, along with
`the data for the detail fields.
`
`[0078] Entries that are found to conflict require a Conflict
`Level indication in the Conflict field. The specific informa-
`tion housed by the AutoExec table 96 and details about each
`column are listed in Table 3 below.
`
`TABLE3
`
`Details
`
`
`
`In the case of this table, as well as
`all other children of the Package
`table, this field contains one of the
`parent designators. In this case, the
`AppKeyis used to indicate that the
`data in this row belongs to a certain
`application; the application
`associated with that particular
`number.
`The PackKeyindicates the version of 1 Microsoft Word
`the application. Different versions of
`3.0
`2. Microsoft Word
`the same application may he
`4.0
`compared for conflicts.
`This numberestablishes the
`AutoExec table as a unique child of
`the Package table. The numbers in
`this field represent particular changes
`that have occurred to the
`autoexec.bat. Each change is unique
`and is therefore assigned a unique
`number foridentification purposes.
`
`Example
`1 Office 97
`3 WordPertect
`
`12
`
`Field
`
`AppKey
`(pk)
`
`Data Type