US20150317347A1

US20150317347A1 - Portable Application Registry

Info

Publication number: US20150317347A1
Application number: US14/706,617
Authority: US
Inventors: Aidan T. Hughes; David A. Yalovsky; Anzhelika Nishanova
Original assignee: Microsoft Technology Licensing LLC
Current assignee: Microsoft Technology Licensing LLC
Priority date: 2005-12-13
Filing date: 2015-05-07
Publication date: 2015-11-05
Also published as: US20110145281A1; US7917487B2; US9031904B2; US20070136241A1

Abstract

The application describes updating, by a computing system, a table to include first data usable to locate a first portion of metadata in a supplementary database that is accessible from a storage device. The metadata is related to one or more functions of an application that execute on the computing system. The table also includes second data usable to locate a second portion of the metadata in a system database of the computing system. During execution of the application, a request for one or more portions of the metadata is received, and the table is used to determine one or more locations of the one or more portions of the metadata of the request. In response to the request, at least one of the first portion of the metadata is read from the supplementary database or the second portion of the metadata is read from the system database.

Description

RELATED APPLICATION

This application is a continuation of U.S. patent application Ser. No. 13/031,090, filed on Feb. 18, 2011, entitled “PORTABLE APPLICATION REGISTRY”, which is a continuation of U.S. patent application Ser. No. 11/275,136, (now U.S. Pat. No. 7,917,487), filed on Dec. 13, 2005, both of which are incorporated by reference herein in their entireties.

BACKGROUND

Software applications often behave in particular ways based on changes made when using that application, such as changes made by a user setting his or her preferences, and/or metadata about an application, such as metadata providing components of the application with a roadmap to other components. A user may, for instance, customize toolbars for his spreadsheet application or a dictionary for his word-processing application's spell checker.
Customizations and other application-specific functionality are generally retained by the application's native computing system—not the application itself. When an application is executed, it interacts with its native computing system's registry to enable its particular functionality.
When an application is saved to a portable device and connected to another computing system, however, the application may behave differently. It can behave differently because the other computing system's registry may not have a record of the application's particular functionality. The afore-mentioned user's spreadsheet application, for example, may have different toolbars or his dictionary not recognize particular words previously added by the user.

SUMMARY

This document describes techniques that enable an application to operate as if the application were miming on its native computing system when it is actually running on another computing system. The techniques may do so by building a portable registry having metadata particular to the application, which can be stored in a portable device along with that application. When that portable device is connected to another computing system, the portable registry may be used to supplement or supplant the other computing system's registry to enable the application to operate with its particular functionality.
This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an exemplary operating environment in which various embodiments can operate.

FIG. 2 is an exemplary process for using a portable registry to supplement or supplant a computing system's registry.

FIG. 3 illustrates an unaltered, exemplary simplified import address table.

FIG. 4 is the import address table of FIG. 3 after alteration to the functions' original addresses.

FIG. 5 illustrates an intermediary attempting to call a function through an exemplary portable registry.

FIG. 6 illustrates a conjunction of an exemplary system registry and an exemplary portable registry.

The same numbers are used throughout the disclosure and figures to reference like components and features.

DETAILED DESCRIPTION

Overview

The following document describes many techniques, some of which enable a portable application to operate on a computing system with functionality associated with the application. These techniques may do so using a portable registry capable of supplementing or supplanting the computing system's registry.
For example, these techniques may enable a user to operate his portable spreadsheet application on a new computing system and use his particular toolbars, or operate his portable word-processing application and spell check words that he previously added to his dictionary.
An environment in which these and other techniques may operate is set forth first below. This is followed by a section entitled Operating on a Computing System, which describes exemplary ways in which a portable application may operate on a computing system using a portable registry.

Exemplary Operating Environment

Before describing the techniques in detail, the following discussion of an exemplary operating environment is provided to assist the reader in understanding one way in which various inventive aspects of the techniques may be employed. The environment described below constitutes but one example and is not intended to limit application of the techniques to any one particular operating environment. Other environments may be used without departing from the spirit and scope of the claimed subject matter.
FIG. 1 illustrates one such operating environment generally at 100 comprising a portable device 102, such as a thumb drive, portable hard drive, compact disc, or other storage device. The portable device comprises computer-readable media 104 having a portable application 106, an intermediary 108, and/or a portable registry 110.
The portable registry may comprise application metadata 112, which may be used by the portable application or an operating system to enable the portable application's particular functionalities and behavior. The application metadata may include information affecting how the portable application behaves, such as how particular functionalities act or are presented (e.g., a toolbar's appearance). For example, the metadata may indicate which interfaces to expose to the portable application and a start menu, icons, or graphics that the portable application uses.
Here the portable storage device stores these elements for later use by a computing system 114. Computing system 114 may initially lack some or all of the application metadata such that the portable application may not perform and behave on the computing system as it should. The computing system comprises one or more processor(s) 116 and computer-readable media 118. The system's processor(s) are capable of accessing and/or executing the media. The media, initially or eventually, comprises or has access to a program loader 120, portable application 106, intermediary 108, a system registry 122, portable registry 110, and application metadata 112. The portable application, the intermediary, the portable registry, and the application metadata may be received from the portable device.

Operating on a Computing System

The following discussion describes exemplary ways in which an application may operate on a computing system using a portable registry.
FIG. 2 is an exemplary process 200 for using a portable registry to supplement or supplant a computing system's registry to enable the application to operate with its particular functionality. It is illustrated as a series of blocks representing individual operations or acts performed by elements of operating environment 100 of FIG. 1, such as portable application 106 and intermediary 108. This process may be implemented in any suitable hardware, software, firmware, or combination thereof; in the case of software and firmware, it represents a set of operations implemented as computer-executable instructions stored in computer-readable media and executable by one or more processors.
Block 202 receives a request for a function or data usable by a portable application. This request may be accessed through a system registry that, were it made to the portable registry, could enable functionality particular to the application.
The portable application's particular functionality may be affected by its own requests or requests from another entity. For example, block 202 may receive the request for a function from the portable application or a module associated with or usable by the portable application. If, for instance, the portable application causes additional library modules to be loaded, which may also request functions affecting the portable application's particular functionality, the module's requested functions may be handled similarly to those from the portable application itself.
Here the request is from portable application 106 and intended for system registry 122.
Block 204 intercepts the request, such as by intermediary 108. The techniques may, in cases where the intermediary is not part of the portable application, enable the portable application and its associated modules to remain unaltered while still enabling the portable application's particular functionality. Block 204 may do so by acting on a request that does not need to be altered or come from a requesting entity that needs to be altered.
In some other cases the intermediary is part of the portable application. In these cases the intermediary intercepts the request to preclude the portable application from requesting a function or data directly from the system registry.
The intermediary may intercept the request by first altering a table of addresses, such as an exemplary, simplified Import Address Table (IAT) 300 in FIG. 3. This IAT is built by the program loader. It provides addresses by which the portable application, when it is executing, may request (directly or indirectly through other modules) data for a particular function. These requests may include opening a registry key, reading or writing a value (one or more times), and closing the registry key.
The program loader populates the IAT with a location. This permits the portable application to call the address in the IAT, which may simply be an integer related to data or a function's memory location (also in the IAT), rather than a particular path. The IAT comprises actual and original addresses, shown at 302. It also comprises IAT addresses 304 associated with these actual addresses. An application may call the IAT address instead of the actual address.
This IAT may, however, be built or altered to permit requesting a function enabled by intermediary 108.
Here the intermediary replaces the original function addresses in the IAT prior to the request, so that, when the portable application first requests a particular IAT address 304, the function associated with that IAT address prompts the intermediary to execute. The intermediary may replace the original function addresses prior to any original function being called by replacing the original function addresses in the IAT very early in the execution of the portable application (e.g., by the portable application calling the intermediary first).
FIG. 4, for example, shows an exemplary altered IAT 400. Here the same IAT addresses 304 are shown, but addresses for intermediary functions 402 are shown instead of the original function addresses 302.
Block 206 determines whether registry data exists to enable functionality particular to an application that is being operated from a portable device on a computing system having a system registry. In some cases application-specific metadata related to the requested function is in the portable registry. In some others, no application-specific metadata is so related. In still others, such as when the requested function repeats to enumerate a complete set of values, application-specific metadata related to the requested function may be in the portable registry but metadata in the system registry may also be related to the requested function.
If block 206 determines that the requested registry data does not have associated metadata related to the portable application (e.g., if the requested data does not exist in the portable registry), it proceeds to block 208. Block 208 does not supplant or supplement the system registry. Here block 208 proceeds to block 210, which reads the requested data from the system registry.
If block 206 determines that the registry data requested has associated metadata related to the portable application and in some cases also that the system registry is not needed, it proceeds to block 212. Block 212 supplants the system registry with the portable registry or its metadata. The intermediary may supplant the system registry by routing a request for data to the portable registry instead of the system registry.
It then proceeds to block 214, which reads the requested data from portable registry. Here the techniques seamlessly integrate metadata associated with particular functionality of the portable application with a system registry such that the portable application retains its particular functionality.
If block 206 determines that the requested registry data has associated metadata related to the portable application and also needs the registry data to be requested from the system registry, it proceeds to block 216. Block 216 supplements the system registry with the portable registry and proceeds to block 214. Block 214 reads the requested registry data from the portable registry. After block 214, however, the process proceeds to block 210 to also read requested data from the system registry. This supplementing of the system registry may occur when multiple iterations of a function are needed, such as to enumerate multiple values.
When the IAT address 304 is called, the intermediary function is instead executed, thereby intercepting execution of the intended function at address 302 and instead executing the intermediary function at the associated address 402.
When executed, the intermediary function first attempts to open a key in the portable registry. The portable registry contains keys and values, with the keys organized hierarchically. Keys may contain other keys or values. The intermediary may also read or write data from or to the portable or system registries. The intermediary function may also close a key.
IAT 300 contains a list of references to Application Programming Interfaces (APIs), which are designed to act on the system registry. These APIs may be intercepted by the intermediary (shown in FIG. 5 using altered IAT 400), which on a case-by-case basis, decides from which registry (portable or system) to read. This decision may be made based on the name of the key or key handle (“HKEY”) provided by the requesting entity. Thus, a given API may read the portable registry for one HKEY and the system registry for a different HKEY.
FIG. 5 illustrates application code attempting to call a function addressed at 502, which is intercepted by the intermediary 108. The requested key is provided through an exemplary portable registry 110 using an HKEY. If that key is available (and thus has portable application metadata associated with it), the requested data is read from the portable registry.
If the requested key is not available (e.g., the HKEY does not represent a key in the portable registry), the intermediary reads the requested data from the system registry (e.g., calling one of original function addresses 302 of FIG. 3 using an appropriate HKEY for that original registry key). If the key is repeatedly read, the system registry may be read in addition to the portable registry.
In some cases, registry keys will need to be altered, such as to write a value. The intermediary may know which registry was previously read for the key by retaining a record of which HKEYs have been successfully read from the portable registry and which have not. When a function is then called that will make an alteration, the intermediary writes the key in the correct registry.
Effectively, the conjunction of the system registry and the portable registry can be functionally similar or even identical to the result of installing a product to the system registry. Graphically this is shown, in simplified form, in FIG. 6. Here the altered addresses 402 of the altered IAT 400 are shown correlating to either a key 602 in the portable registry or an address 604 in the system registry API (which is the same as that of the original function addresses 302 of IAT 300). The sections of the portable registry without keys are shown blank. The correlation is shown between the original address and the portable or registries with arrows for clarity, though they may not line up in this fashion.

CONCLUSION

The above-described techniques enable an application to operate on a computing system as though it were installed on that computing system. These techniques may do so using a portable registry capable of supplementing or supplanting a computing system's registry. These techniques may provide significant improvements over the current state of the art, potentially enabling users to use their portable applications on computing systems without those portable applications behaving differently than they would had they been installed to those computing systems. Although these techniques have been described in language specific to structural features and/or methodological acts, it is to be understood that the techniques defined in the appended claims are not necessarily limited to the specific features or acts described. Rather, the specific features and acts are disclosed as exemplary forms of implementing the claimed techniques.

Claims

1-20. (canceled)

21. A method, comprising:

updating, by a computing system, a table to include first data usable to locate a first portion of metadata in a supplementary database that is accessible from a storage device, the metadata related to one or more functions of an application executing on the computing system, the table also including second data usable to locate a second portion of the metadata in a system database of the computing system;

receiving, during execution of the application, a request for one or more portions of the metadata;

determining, from the table, one or more locations of the one or more portions of the metadata of the request; and

responding to the request by at least one of reading the first portion of the metadata from the supplementary database or reading the second portion of the metadata from the system database.

22. The method of claim 21, wherein at least the one or more functions associated with the first portion of the metadata stored in the supplementary database include at least one customized function of the application.

23. The method of claim 21, wherein the updating includes replacing third data in the table with the first data, the third data usable to locate a third portion of the metadata in the system database of the computing system, the third data associated with at least the first one of the one or more functions.

24. The method of claim 21, wherein the request for one or more portions of the metadata includes a request for both the first portion of the metadata and the second portion of the metadata, and the method further comprises retrieving the first portion of the metadata based on the first data usable to locate the first portion of the metadata, and retrieving the second portion of the metadata based on the second data usable to locate the second portion.

25. The method of claim 21, wherein the updating the table to include the first data and second data usable to locate a second portion of the metadata in a system database of the computing system creates a combined database.

26. The method of claim 21, wherein the metadata includes a key, and the reading the one or more portions of the metadata of the request includes attempting to open the key.

27. The method of claim 21, wherein the first data usable to locate a first portion of the metadata includes a reference to an application programming interface that accesses the first portion of the metadata, and the request includes a request to call the application programming interface.

28. The method of claim 21, wherein the request is associated with a function call.

29. A computing system comprising

one or more processors;

memory; and

programming instructions stored on the memory and executable by the one or more processors to perform acts comprising:

accessing a supplementary database from a device that stores the supplementary database;

updating a table usable to access metadata associated with functionality of an application, the updating including writing first data to the table that is usable to access a first portion of the metadata from supplementary database, the table also including second data that is usable to locate a second portion of the metadata from a system database;

30. The computing system of claim 29, wherein the updating the table results in a combined database that includes the supplementary database and the system database.

31. The computing system of claim 29, wherein the functionality of the application includes at least a customizable function of the application, and the first portion of the metadata stored in the supplementary database describes a customization to the application that is associated with the customizable function.

32. The computing system of claim 29, wherein the one or more portions of the metadata include the first portion of the metadata and the second portion of the metadata, and the acts further comprise reading the first portion of the metadata based at least the first data usable to access the first portion of the metadata, and reading the second portion of the metadata based at least on the second data usable to access the second portion of the metadata.

33. The computing system of claim 29, wherein the first data usable to access the first metadata includes a reference to an application programming interface that accesses the first portion of the metadata.

34. The computing system of claim 29, wherein the first data usable to access the first metadata includes an address of the supplementary database.

35. The computing device of claim 29, wherein the updating the table to include the first data usable to access the first portion of the metadata includes replacing third data usable to access a third portion of the metadata that is stored in the system database.

36. A storage device comprising one or more programming instructions that are executable by one or more processors of a computing system to:

update a table created by a program loader of the computing system to include first data usable to access a first portion of metadata in a supplementary database, the first portion of the metadata associated with a customizable function of an application, the table also including second data usable to access a second portion of the metadata in a system database of the computing system;

receive, during execution of the application, a request for one or more portions of the metadata;

determine, based on the table, to access the one or more portions of the metadata from at least one of the supplementary database or the system database; and

respond to the request by accessing the one or more portions of the metadata from at least one of the supplementary database or the system database.

37. The storage device of claim 36, wherein the update of the table to include both the first data usable to access the first portion of the metadata from the supplementary database and the second data usable to access the second portion of the metadata from the system database results in a combined database.

38. The storage device of claim 36, wherein the supplementary database and the system database include, respectively, a supplementary registry and a system registry.

39. The storage device of claim 36, wherein the one or more programming instructions are further executable by one or more processors of the computing system to update the table to include the first data usable to access the first portion of the metadata by at least replacing third data with the first data, the third data usable to access a third portion of the metadata that is stored in the system database.

40. The storage device of claim 36, wherein the first data usable to access the first portion of the metadata from the supplementary database includes one or more of:

a reference to an application programming interface that accesses the first portion of the metadata; and

a key handle that identifies a key and value pair in the supplementary database.