JPH07230380A - Method and system for controlling utilization of application program - Google Patents

Abstract

PURPOSE: To detect only the trial of the execution call of an applied job program by loading operating system kernel DLL executing the applied job program on a program memory when the execution of a DLL routine satisfies management condition logic permitting the execution of the applied program. CONSTITUTION: The applied job programs by which the use of the execution of the DLL routine is detected or monitored scan the header part 1 for detecting DLL reference against DOSCALL. DLL reference starts the operating system or refers to a kernel code 2. Respective references are substituted for interception DLL and the new routine for executing a management logic function is called. When the parameter of the logic function is within the condition, operating system kernel DLL is loaded on the program memory. The trial of the execution call of the applied job program can be detected.

Description

Detailed Description of the Invention

[0001]

FIELD OF THE INVENTION The present invention relates generally to computer system resource management systems and methods, and more particularly to managing installation and usage plans of software such as application programs in distributed or network environments. It is about how to do it.

[0002]

The widespread proliferation of interconnected personal computers, workstations or mid-sized computers over communications networks has magnified the problem of software asset management. Software customers often need to know what programs are running on their network at a particular point in time and make a status report. The customer has a right to use the program, whether the license is granted, the number of users for each software asset recognized by the software vendor,
The number of current users and the total number of authorized users, the identification number of each user's location or machine, the number of times the software asset has been used, the total time of use, and, as the case may be, the software asset license agreement. It is necessary to know the remaining license time etc.

A common point of all of these management inquiries is a mechanism that can detect a plan of introduction and execution of an application program by a user at any place on the network. This is particularly relevant for misuse of assets, as it limits the use of the customer within the scope of the license terms set by the software supplier, as well as asset management within an entity such as a company. It is also necessary for the responsibility of protecting assets in terms of potential scandals caused by outsiders or criminals. Local Area Networks (LANs) have exacerbated this problem significantly and increased the problem of software licensing.

Software piracy is a large and growing problem in the software industry. The accessibility currently provided by networks or LANs has dramatically increased the use of software by unlicensed users or piracy.

It is customary that a software distributor grants a right of use to a user and requests the user to perform management within the range of the license conditions.

[0006] Software distributor permission restrictions, restrictions,
Various tools are available for managing compliance with terms of use agreements, but they do not adequately address typical network environments.

The problem is further exacerbated by the advent of new types of license terms for software assets. The most common licensing arrangement historically known is what is known as "machine-level" licensing, and this software license term allows the software to run on only one designated machine at a time. Demand that you can.
As the network system grows, many workstations or personal computers can access the same software product over the network, even if the software product is installed on only one machine. These types of licenses have lost their appeal. Some license terms exclude this shared or networked use to prevent unauthorized use or copying of the software.

Various license formats are currently in use.
Some do not change the traditional "use" permissions. Such a form of license limits the use of the application program to a fixed number of users executing the same asset at any one time. Another form is "purchase after trial", which allows a user to try a predetermined number of times before purchasing a software product. Another recent increase is the “pay-per-use” form, which is a method of renting based on actual use. Another form of license called "Term of Use" is that the software is licensed for a period of time, after which the contract must be terminated or renewed.

As the number of new licensing schemes increases, those licensing schemes not only need to detect an attempt to execute a given application program, but also need a mechanism to prevent the execution if the licensing conditions are not observed. .

The management software vendors provide software management tools that address the above-mentioned software license condition compliance problem. The mainstream form of such a solution requires that the license application software be installed on a LAN server rather than on individual machines. In this case, the LAN server can operate a management program that limits the number of users or the number of accesses at one point. Such network-based schemes are popular with software vendors because they can control access to assets from a single point in the system. This scheme takes advantage of the unique features of the LAN network operating system to control access to shared resources such as software application programs. However, this solution is not the ultimate because the software must be installed on the LAN server in order for the licensing conditions to be complied with and managed. The above approach is clearly unsuitable for many software products that either run very slowly when installed on a LAN server or need to physically reside on the user's workstation.

Thus, in order to recognize that the software resides on the user's workstation and still control its execution, a method is provided with software management tools that detect attempts to execute the software and, under certain conditions, stop it. Are required for all major operating systems. The preferred solution must be general and widespread, but unfortunately not all major operating systems provide such functionality.

[0012] A typical DOS (Disk Operat)
ing System) is to develop a software tool that detects an interrupt at the specified operating system level to detect the execution of a program and stops its execution if the usage is not within the range of the licensed parameters. Provide a mechanism that allows Special interfaces have been created in the operating system that allow the development of management programs. This interface allows the management programs themselves to register themselves with the operating system so that they will be notified when a given program is loaded for execution. However, some other operating systems, such as IBM OS / 2, have no provision for detecting or preventing the execution of programs.

[0013]

With respect to the above-noted difficulties and limitations overlooked in the prior art, the present invention seeks to execute an application program in an operating system of a personal computer, workstation or other similar machine. The aim is to provide an improved detection method and system.

[0014]

The present invention, as illustrated in particular herein by way of preferred embodiments, is, for example, in the OS / 2 operating system, any application program
It is based on the recognition of the fact that it always holds a control header of information that contains a particular call to a system program. One such call is the operating
The kernel required to launch the system action
Dynamic binding library or dynamic containing code
A specific DO for a linked library routine (abbreviated as DLL below)
It is SCALL. In the present invention, each application program whose use is detected or monitored for management is D
Its header portion is scanned to find the DLL reference to OSCALL. DLL references refer to kernel code for booting an operating system. In the present invention, each such reference is replaced with an intercept DLL. Intercept DL
L calls a new routine that performs a management logic function, and if the parameters of that logic function are in the condition,
Returns operational control to the native operating system kernel.

[0015]

EXAMPLE A solution to the above problem is IBM OS / 2.
All application software programs designed to run on operating systems are
D including S / 2 operating system kernel
It is based on the fact that the LL (Dynamic Link Library) has to be loaded first. Only through the interface provided by this DLL routine can the application program execute or invoke any of the operating system's functions.

Each executable module code in the application program is a linker (linkage editing program).
It has a header containing certain information stored at the beginning of the file created when the program is created. When the program is run, the header information is read by the OS / 2 program loader. It gives the loader a lot of important information needed to start the program initialization and execution. Among the information needed by the program loader is the name of the DLL that the operating system must preload before passing control to the application program. Pre-load
One entry that is always in the list is "DOSCAL
OS / 2 kernel DLL named "LS.DLL".

Whenever a DLL is loaded by the operating system, the system first executes special code present in each DLL routine, called the "initialization header routine." If for some reason the initialization header routine fails to execute, an indicator of that fact will be returned to the operating system and the application program will not be loaded or executed.

The solution of the present invention is DOSCALLS.
DLL specifications are detected in the executable header part and DOSCA
The LLS.DLL is replaced with a call to another DLL. Another DLL is DOSCAL
It has its own initialization routine that is called instead of LS. This new replacement DLL, also referred to as an "intercept DLL," is automatically executed by a utility routine that searches each application program executable module and replaces the DOSCALLS.DLL kernel call with the intercept DLL's identifier. The intercept DLL initialization / termination routine is
Written to include the necessary management logic functions.

Any attempt to execute an application program containing an intercept DLL will result in intercept D
It is automatically detected because the LL notices that it is attempting to execute at the time of its invocation. The fact of this execution attempt is compared with the permitted number of permitted uses, the permitted user identification number, etc., which are recorded, summed, and stored, depending on the degree required to process the initially determined management task. The name of the application program attempting to execute can be used by an intercept DLL initialization routine that controls the execution of the program, records, reports, or terminates the appropriate logic needed to stop execution. The set can be executed. If the attempt to execute is found to exceed the license limit, and therefore does not load or execute, then a DLL load failure indicator is issued and returned to the operating system.

If the management function of the intercept DLL's initialization routine completes successfully, the application program is allowed to undertake normal setup and begin execution. This is easily accomplished by an initialization routine in the intercept DLL that includes an export call to the original DOSCALLS.DLL kernel to trigger the actions that would normally occur if the intercept DLL were not present. The end part of the intercept DLL detects the end of execution of the application program,
If an important factor, it can be set to time or report that the current license limit should be decremented by termination of use at the workstation or computer.

The intercept DLL is the "DLLI" which is the entry point (ENTRY) called by OS / 2 when the DLL is loaded or unloaded.
Must be created using nitTerm ".
Table 1 at the end of this specification shows a typical configuration of an intercept DLL that includes this entry point. This new D
The name of the LL or intercept DLL must be included in the module definition file shown in Table 2. This is the name that replaces the normal DOSCALLS.DLL in the application program's executable header information. A simple tool that can search for application program execution attempts, locate the DLL entry list in the module's header, find DOSCALLS, and replace them with the intercepted DOSCALLS module names in Table 2 is shown in FIG. Can be created as follows.

FIG. 1 shows that an application program operating in the OS / 2 environment has DOSCALL in its description header.
FIG. 5 is a diagram visually showing how to include a DLL reference list for preloading a DLL containing a request. Figure 1
When the DOSCALL reference is found in the application program header, the operating system D
It shows how to launch the OSCALL DLL kernel and initiate the initialization / termination routines required to launch an operation by the operating system. These DLLs
Each of these are loaded by the operating system during the loading of the application program. DOSC
The ALL DLL is in the DLL reference list above because it contains the operating system kernel ADIS.

FIG. 2 shows the DOSCALL intercept D.
FIG. 6 illustrates operation of the preferred embodiment of the present invention including LL sequences.

FIG. 3 is a diagram showing an initialization process for making a replacement for DOSCALL in the application program header.

FIG. 4 illustrates the logic flow of the operations of FIG. 2 in which the steps performed intercept the DOSCALL attempt to the operating system kernel and instead include the appropriate management logic functions. It is a figure which shows the step which performs the conversion / termination routine.

FIG. 5 is a diagram illustrating a typical computer system in which the present invention may be implemented.

The normal DOSCALLS.DLL process is shown in FIG. In Box 1 of Figure 1, the normal O
Shown is the application program being launched for execution in the S / 2 executable environment. The application program has an executable header (EXE HEADER) containing a reference list of DLLs that must be preloaded. In them, as shown in the figure, DOSCALLS.D
There is an LL reference. As shown in Box 2 of FIG.
This DLL contains the kernel code needed for initialization / termination routines and links to other components of the operating system.

Next, referring to FIG. 2, the intercept DLL
The function of the reference "DOSCALLX" is indicated. The executable header information of the application program has "DOSCALLX" in which the DLL reference list is modified and the original DOSCALLS reference specification is rewritten. In this example, "DO
SCALLX "is an arbitrarily chosen name for the intercept DLL. The operation of the system is then DOSCA, which includes replacement initialization / termination routines and asset management logic.
Proceed to access to LLX.DLL. In this asset management logic, whether there is a license currently valid for executing this application program, what kind of license limit or number of times there is, or whether or not the user limit is exceeded.
The machine identification number matches the licensed identification number, the number of licensed uses, the total elapsed time of use, whether the expiration date has been exhausted, etc. And some logical control items that are included.

The original DOSCAL is displayed in box 1 in FIG.
Executable header information (EXE H) of application programs having DOSCALLX that replaces LS.DLL
EADER) is shown. In Box 3, this D
An intercept DLL named DOSCALLX containing initialization / termination routines and management logic for the LL
It is shown. Also shown in the figure is a link to the DOSCALLS.DLL kernel when the intercept DLL determines that the invocation and execution of the application program is within the prescribed limits. This is illustrated by the linking of the DOSCALLS.DLL kernel from box 3 to box 2 in FIG.

FIG. 3 shows a schematic of the intercept DLL insertion routine. The operation begins at block 4 and proceeds to block 5 which searches the application program header for the DOSCALLS.DLL kernel specification. This search is done in block 5 and DOSCALL
Block 6 when S.DLL kernel call is found
, The DLL kernel is replaced with the intercept DLL's distinguished name. When the replacement is complete, the process ends at block 7.

FIG. 4 shows the general operation when the user starts the application program having the application program header modified by the process of FIG. The operation begins at block 8 with a user initiated or initial command to launch an application program.

At block 9, the user launches the application program by name or command, so that at block 10, the operating system searches the application program header for the request DLL to be preloaded. . In block 11, this request DLL
Is loaded by the operating system,
At block 12, the intercepting DLL, DLL, is executed and an initialization routine with management function logic is executed, as indicated by box 3 in FIG. As a result of the execution in block 12, it is determined in block 13 whether or not the application program of the user is permitted to execute. If allowed, a pass-through (control transfer) to the original DLL kernel, indicated by box 3 in FIG. 2, occurs (block 15). Therefore, in block 16, the original DOSCA
The LLS.DLL kernel start / end routine is executed. At block 17, execution of the application program continues, and upon termination of the application program, control is returned to the operating system (block 18), the manager logic termination routine is executed (block 19), and the process ends. (Block 20).

Returning to block 13 of FIG. 4, if the execution of the user or application program is not permitted by the management logic function, which indicates that the defined usage parameters are not met, the execution is denied. Marking
A message is displayed to the user that describes the related reasons such as “unlicensed program”, “deviation of permission limit”, and “use beyond the number of times of permission”.

As will be appreciated by those skilled in the art, any particular management logic function can be readily programmed with respect to the execution behavior of the intercept DLL's start / end routines. Proper administrative decisions could easily be made by reference to a number of registers. Such a register is preloaded with a license limitation, a licensee identification number list, a usage time or a frequency of use, which can be updated periodically by communication with a user workstation or a terminal on the network.

FIG. 5 illustrates a typical computer system 21 for implementing the present invention. Some of the systems form a typical node in a communication network such as a local area network (LAN) or distributed complex node communication across national or international.

In FIG. 5, computer system 2
1 includes a central processing unit (CPU) 22 that incorporates an operating system, read-only memory (ROM) for processor resident control code, and an arithmetic logic unit (ALU). A display device 23 such as a CRT, printer or other means for communicating with the operator
Connect to PU22. Mouse, keyboard, joystick, voice input device and other user input devices 2
4 connects to the CPU. Bidirectional communication between the CPU 22 and a direct access storage device such as disk storage device 26 or mass memory 25 is also provided in the system. The audio output device 27 may be connected to the system as in the case of a multimedia terminal or personal computer, and the computer system 21 may be connected to a number of other computer systems via a communication network or LAN. Thus, peripheral I / O controller 28 having a communication port connected to communication link 29 can be connected to the system.

Although the present invention has been illustrated and described above with respect to a preferred embodiment, many interceptor routines are provided to intercept the various interceptor DLLs to suit the various requirements of the supervisory functions.
It will be apparent to those skilled in the art that it can be incorporated into the initialization / termination routine code of

[0038]

[Table 1] C source code sample implementing DLL initialization header int _CRT_init (void); void _CRT_term (void); static PIB pib; static PTIB tib; unsigned long _System _DLL_InitTerm (unsigned long hModule, unsigned long ulFlag) {switch (ulFlag) {case 0: // Indicates "start of program" {if (_CRT_init () ==-1) // Requested if unsuccessful return 0UL; // Load failed // Program tries to execute .. .. // One way to get the name of the program to execute // Use DosGetInfoBlocks (& tib, &pib); // pib-> pib_pchcmd is the command used to start the program // Keep the row if (PermissionToRun ()) // perform the necessary checks return (1UL); // OK-load successful return (0UL); // load failed break;} case 1: // 'program stop' Indicates {_CRT_term (); // Execute the termination logic return 1UL; // OK}} return 0ul;}

[0039]

Table 2 Sample Module Definition File for Intercept DLL The following is a sample module definition file that can be used to create an intercept DLL named DOSCALLX.DLL. DLL DOSCALLX
It should be noted that the export in () is the control transmission (pass-through) itself to the export in DOSCALLS. -------------------------------------------------- --------------- LIBRARY DOSCALLX INITINSTANCE TERMINSTANCE PROTMODE DATA NONSHARED MULTIPLE LOADONCALL CODE SHARED LOADONCALL IMPORTS aOOOOOOl = DOSCALLS.1 aOOOOOO2 = DOSCALLS.2 aOOOOOO3 = DOSCALLS.3 .. .. .. aOOOO500 = DOSCALLS.500 EXPORTS aOOOOOOl @l aOOOOOO2 @ 2 aOOOOOO3 @ 3 .. .. aOOOO500 @ 500 _CRT_init As a summary, the following items are disclosed regarding the configuration of the present invention. (1) In a computer system having a processor, a program memory, and an operating system for executing a program, the application program is used by detecting an attempt to execute the application program by the processor. A dynamic link library (DL)
L) reading the header portion of the application program holding the reference, loading the DLL routine identified in the header portion of the application program into the program memory, and program logic included in the DLL routine. And executing at least one of the DLL routines satisfies a management condition logic that permits execution of the application program. Loading the DLL containing the kernel into program memory, and managing the use of the application program. (2) As a record of an attempt to use the application program, at least one DLL including the management condition
A method for managing the use of the application program according to (1), further including recording the execution of the above in the memory. (3) The method of managing the use of the application program according to (2), further including the step of recording a record of the identifier of the application program in the memory. (4) The method of managing the use of the application program according to (3), further including recording a record of the execution start time of the application program in the memory. (5) The above (1), (2), (including the step of passing operation control from the operating system to at least one DLL including the management condition logic at the end of the execution of the application program. A method of managing the use of the application program described in 3) or (4). (6) The method of managing the use of the application program according to (5), further including the step of recording a record of the execution end time of the application program in the memory. (7) A step of searching the header part of the application program to find a reference to the kernel DLL of the operating system, and replacing the DLL reference in the header part of the application program with a replacement DL
A step of replacing L with a replacement DLL that identifies L, with a condition for passing execution control from the replacement DLL to the kernel DLL of the application program execution operating system only when the management condition is satisfied. (1), (2), (3), (4), (5) or (6), further including a replacement step including management condition logic having a pointer
A method of managing the use of the application program described in. (8) comparing the record of the application program use attempt with a pre-stored number representing the licensed use limit of the application program; and the use attempted use limit licensed. Of the application program according to (2), (3) or (4), further comprising: loading the DLL including the kernel of the operating system into the program memory only if How to manage usage. (9) Computer software assets in a computer system having a processor, a program memory, an operating system for executing a program, and at least one application program software asset whose use is managed. And a means for finding a dynamic link library (DLL) reference described in the header part of the application program software asset by reading the header part of the application program software asset, and a program for executing the found DLL. .Means for loading into memory and D loaded above
A means for executing the program logic contained in the LL and, in response to executing the program logic of the at least one DLL, another DLL containing a kernel of the operating system is loaded into the program memory, at least 1
A computer software asset management system comprising: means for permitting execution of the application program only when it is determined that predetermined management condition logic is satisfied by execution of one of the DLL program logics.

[0040]

According to the present invention, the operating system kernel DLL reference is searched from the header information of each application, and this operating system kernel D is searched.
Detects an application program execution call attempt by replacing the LL reference with an intercept routine DLL reference. The intercept routine is activated in response to an attempt to call the application program, and includes management logic relating to the necessary software asset management function prior to execution of the application program. With these configurations, proper use and management of software resources can be achieved even in a distributed environment or network environment.

[Brief description of drawings]

FIG. 1 is a DLL in which an application program operating in an OS / 2 environment includes a DOSCALL request in its descriptive header.
FIG. 6 is a diagram visually showing how to include a DLL reference list for preloading of a.

FIG. 2 is a diagram showing the operation of a preferred embodiment of the present invention including a DOSCALL intercept DLL sequence.

[Fig. 3] DOSC in application program header
FIG. 6 shows an initial process of making a replacement for ALL.

FIG. 4 is a diagram showing a logic flow of the operation of FIG. 2;

FIG. 5 illustrates a typical computer system in which the present invention may be implemented.

[Explanation of symbols]

 21 computer system 22 CPU 23 display device 24 user input device 25 memory 26 disk storage device 27 audio output device 28 peripheral input / output control device 29 communication link

Claims (9)

[Claims] 1. A computer system having a processor, a program memory, and an operating system for executing the program, whereby the application program is detected by the processor detecting an attempt to execute the application program. A method of managing usage, comprising: reading a header portion of an application program holding a dynamic link library (DLL) reference; and including a DLL routine identified in the header portion of the application program Loading into memory, executing program logic contained in the DLL routine, and determining that at least one execution of the DLL routine satisfies management condition logic that permits execution of the application program. And only in the case of loading a DLL including a kernel of an operating system for executing the application program into a program memory, and a method of managing the use of the application program. 2. The use of the application program according to claim 1, further comprising a step of recording, in the memory, at least one execution of the DLL including the management condition, as a record of an attempt to use the application program. How to manage. 3. The method further comprising the step of recording a record of an identifier of the application program in the memory.
How to manage the use of the application programs listed. 4. The method for managing use of an application program according to claim 3, further comprising the step of recording a record of an execution start time of the application program in the memory. 5. The method of claim 1, further comprising the step of passing operation control from the operating system to at least one DLL containing the management condition logic at the end of execution of the application program. A method of managing the use of the application program described in 4. 6. The method for managing use of an application program according to claim 5, further comprising the step of recording a record of an execution end time of the application program in the memory. 7. The kernel D of the operating system is searched by searching the header part of the application program.
Finding a reference to the LL and the DL in the header part of the application program
Replacing the L reference with a replacement DLL that identifies the replacement DLL, the replacement DLL comprising:
A replacement step comprising management condition logic having a conditional pointer for passing execution control from said replacement DLL to said application program execution operating system kernel DLL only if management conditions are met. A method for managing the use of the application program described in 1, 2, 3, 4, 5 or 6. 8. A step of comparing said record of attempts to use said application program with a pre-stored number representing a licensed limit of use of said application program; said attempt to use said licensed. Managing the use of the application program according to claim 2, 3 or 4, further comprising: loading the DLL containing the operating system kernel into the program memory only if the limit is not exceeded. Method. 9. A computer comprising a processor, a program memory, an operating system for executing a program, and at least one application program software asset whose use is managed.
A system for managing computer software assets in a system, a means for reading a header part of the application program software assets to find a dynamic link library (DLL) reference described in the header part, A means for loading the found DLL into the program memory; a means for executing the program logic contained in the loaded DLL; and a kernel of an operating system responsive to the execution of at least one program logic of the DLL. A means for loading another DLL, including the above, into the program memory, and permitting the execution of the application program only when it is determined that the execution of at least one of the program logics of the DLL satisfies the predetermined management condition logic. And including compilations Management system of over data software assets.