Patching rebased and realigned executable files

Details Patching rebased and realigned executable files Patching rebased and realigned executable files

1998-04-17

2001-05-08

Trammell, James P. (Department: 2161)

Data processing: software development, installation, and managem

Software program development tool

Translation of code

C717S152000

Reexamination Certificate

active

06230316

ABSTRACT:

FIELD OF INVENTION
This invention pertains to the field of software updating. More specifically, this invention pertains to a system and method for performing an update to an executable file which has undergone rebasing or realigning.
BACKGROUND OF THE INVENTION
Some computer software publishers update their software applications (computer programs and data files associated with the programs) frequently. These updates often add new features to the applications as well as remove existing bugs. Several methods are commonly used to update software applications. The simplest of these is to distribute one entire software application to replace an older one. This full update method is simple, but expensive and inconvenient. Typically the software is distributed on some type of removable media, such as floppy disks or CD-ROMs, which are costly to produce and distribute. The time an end user must wait for the removable medium to arrive and the time it takes for the software application to install itself on a computer system are inconvenient. This inconvenience is compounded where updates occur frequently.
Because of the large size of many software applications it is generally not feasible to distribute such updates over computer networks, such as the Internet. When full updates of larger applications are distributed over the Internet, they often cause such high loads on servers that other users suffer slow-downs on the network, and the servers have trouble meeting the demands.
In order to bypass many of the problems associated with this type of software updating, some software publishers distribute incremental updates. These updates do not contain entire software applications, but rather they contain that information which is necessary to transform a particular version of a software application to a newer version. Among the methods available to perform such incremental software updating is binary patching, performed by programs such as RTPatch, published by Pocket Soft, Inc. A binary patcher changes those binary bits of a software application which are different in a newer version. Because many software updates involve changes to only a small portion of a software application, a binary patcher needs, in addition to the old software application, only a small data file which includes the differences between the two versions. The smaller data files distributed for a binary patch update are often less than 1% of the size of a full update, taking advantage of the large amount of redundancy in the two versions.
The use of incremental update methods allows for smaller updates which can be distributed by means which are not conducive to the distribution of full updates, such as distribution over the Internet. The smaller incremental updates also make distribution by floppy disk more feasible where a full update would have required many disks, and an incremental update may require only one.
Conventional incremental update methods, however, require that application files being updated conform exactly to a known pre-update version. Because binary updating occurs by moving and replacing selected bits of a file, any differences between the file being updated and the expected pre-update file can produce unpredictable results.
There are a variety of ways in which files containing executable code modules can be modified in order to operate more effectively on a particular operating system or a particular computer system. Two of these ways are “rebasing” and “realigning.” Rebasing is the changing of information in a file in order to accommodate the file being loaded into memory at a new base address. Typically, rebasing involves changing absolute memory addresses which appear in code and data segments, so that the correct memory addresses appear. Realigning is the moving of code and data segments within a file such that the segments begin on particular numerical boundaries. Rebasing and realigning are explained in more detail below. Both of these forms of file manipulation create files which can be different from the original files installed on the system. When a software publisher wishes to update earlier versions of an application to a new version through incremental updating, the publisher generally assumes that the files being updated match one of a definite number of past versions. Update patches for these known versions can be produced and sent to users. If some of the application files have been rebased, realigned, or both, these application files will not be in a recognizable format for updating with the incremental update. Because the rebased or realigned file will generally not be available to the publisher of the incremental update, conventional incremental update methods are insufficient.
What is needed is a system for performing incremental updates to application files which have been rebased, realigned, or both.
SUMMARY OF THE INVENTION
The present invention is a system, computer implemented method, and computer readable medium for allowing incremental updating of a file (
100
) which has been rebased or realigned. A canonical form (
100
B) is provided. In terms of rebasing, a canonical form (
100
B) is one which has been rebased to a predetermined base address (
104
). In one embodiment this predetermined base address (
104
) is zero. In terms of realigning, a canonical form (
100
B) is one which has been realigned in a predetermined way. In one embodiment, the segments (
110
) of the file (
100
) are realigned such that there are no unused memory locations (
114
) between the end of one segment (
110
) and the start of the next segment (
110
). In another embodiment, the segments (
110
) of the file (
100
) are realigned to page boundaries (
112
) of a predetermined size.
An incremental update (
124
) for the file (
100
) is determined which transforms the file (
100
) from the canonical form (
100
B) to the desired update form (
100
C). The process of updating the file (
100
) comprises transforming the file (
100
) to the canonical form (
100
B) and applying the incremental update (
124
) to the canonical form (
100
B), resulting in the desire update form (
100
C).


REFERENCES:
patent: 5359730 (1994-10-01), Marron
patent: 5450589 (1995-09-01), Maebayashi et al.
patent: 5481713 (1996-01-01), Wetmore et al.
patent: 5497492 (1996-03-01), Zbikowski et al.
patent: 5546586 (1996-08-01), Wetmore et al.
patent: 5577244 (1996-11-01), Killebrew et al.
patent: 5583983 (1996-12-01), Schmitter
patent: 5588143 (1996-12-01), Stupek, Jr. et al.
patent: 5694566 (1997-12-01), Nagae
patent: 5699275 (1997-12-01), Beasley et al.
patent: 5732275 (1998-03-01), Kullick et al.
patent: 5835701 (1998-11-01), Hastings
patent: WO 93/00633 (1993-01-01), None
patent: WO 97/12508 (1997-04-01), None
Beem, C.; “Transforming Algebraically-Based Object Models into a Canonical Form for Design Refinement”. Air Force Institute of Technology, Wright-Patterson AFB, OH, Jun. 1995.*
Hinchey, M.; Cahill, T.; “Towards a canonical specification of document structures”. ACM Digital Library [online]. Proceedings of the 10th annual international conference on systems documentation in SIGDOC 1992, Feb. 1997.*
Auerbach, J.; “TACT: A Protocol Conversion Toolkit”, IEEE/IEE Electronic Library [online]. IEEE Journal on Selected Areas in Communications, vol 8, Iss. 1, pp. 143-159, Jan. 1990.*
Taylor et al.; “Optimization: App Build Process”. Microsoft Corporation, Microsoft Developer Network Library[online], Feb. 1998.*
Cygnus Solutions; “Debuging with GDB: The GNU source-level debugger”. Cygnus Technical Publications, Accessed online Jun. 2, 1999, Retrieved from the Internet: http://www.cygnus.com., Apr. 1993.*
Coppieters, K: “A Cross-Platform Binary Diff,” Dr. Dobb's Journal, May 1995, pp. 32+35-36.
O'Leary, Michael J., “Portable Executable Format”, Microsoft Developer Supoort, Nov., 1997.

Affiliated with

Also associated with

Rating

Patching rebased and realigned executable files does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Patching rebased and realigned executable files, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Patching rebased and realigned executable files will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-2556400