United States Patent [191
`Wiggins
`
`‘
`
`lllllllllllllllllllllllllllllllll
`SOO5717604A
`[11] Patent Number:
`[45] Date of Patent:
`
`5,717,604
`Feb. 10, 1998
`
`[54] NETWORK MONITORING SYSTEM FOR
`TRACKING, BILLING AND RECOVERING
`LICENSES
`
`[76] Inventor: Christopher Wiggins, 5207 Claremont,
`Midland, Mich. 48642
`
`[21] Appl. No.: 450,618
`[22] Filed:
`May 25, 1995
`
`[51] Int. Cl.‘ ...................................................... .. G06F 7/00
`[52] US. Cl. ............................... .. 364/514 C; 395/200.11;
`395/187.01
`[58] Field of Search ........................ .. 364/514 C, 464.01;
`380/4, 30, 49; 395/187.01, 200.11, 326,
`340, 680, 682, 838
`
`[56]
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`4,924,378
`
`5/1990 Hershey et a1. ................. .. 395/187.01
`
`
`
`5,023,907 5,386,369
`
`
`
`6/1991 Johnson et a1. 1/1995 Christiano ........................ .. 364/46401
`
`OTHER PUBLICATIONS
`
`Dialog Pocket Guide—-Dia1og Information Services 1994
`(no month) p. 61.
`Primary Examiner—James P. Trammell
`Assistant Examiner—Thomas Peeso
`Attorney, Agent, or Firm-Michael D. Wiggins
`
`[57]
`
`ABSTRACT
`
`A network monitoring system operates on a computer
`including processor for running a multi-taslo'ng operating
`system capable of having active and inactive windows. The
`computer is connected to a server or a service which
`provides access to a user application subject to a license
`restriction. When the user application is associated with the
`active window, the user application is executed by the
`processor. A license recovering system includes a display
`coupled to the processor for displaying a user interface of the
`operating system. A user prompting device, run by the
`processor, the display and associated with an inactive
`window, prompts a user when the the inactive window has
`been inactive for a period greater than a ?rst predetermined
`period. A closing device closes the user application when the
`inactive window has been inactive for a period greater than
`a second predetermined period. The network monitoring
`system also includes a real-time billing system for billing the
`computer user for access time to the user application subject
`to the license restriction to alleviate problems occurring in
`shared license pools on a network The network monitoring
`system also includes a user priority system which de?nes
`user priorities for the application shared on the network. The
`priority system closes a current user accessing the user
`application if the priority of a new user requesting access is
`greater than the priority of the current user or if the appli
`cation of the current user is idle.
`
`29 Claims, 5 Drawing Sheets
`
`l
`
`E
`
`Microprocessor (1Tb :
`i /“
`E A
`Internal
`3
`Memory
`
`‘r; C
`E
`
`7
`
`Other l/O Devices
`
`Keyboard
`
`Display
`
`V
`
`External Memory
`
`/50
`
`/52
`/54
`
`Local Server
`E =Appl. #1
`F = Appl. #2
`G = Appl. #3
`H = Appl. #4
`Etc.
`
`/ss
`
`Service
`
`38/
`
`L
`
`WAN
`
`Petitioner Apple Inc. - Ex. 1011, p. 1
`
`

`
`US. Patent
`
`Feb. 10, 1998
`
`sheet 1 on
`
`5,717,604
`
`Figure 1
`Prior Art
`
`\Q /B H11
`
`' HI [I
`
`A
`
`v
`WAN
`
`LAN
`
`Petitioner Apple Inc. - Ex. 1011, p. 2
`
`

`
`US. Patent
`
`Feb. 10, 1998
`
`Sheet 2 of 5
`
`5,717,604
`
`Figure 3
`
`46
`
`‘
`
`Keyboard
`
`Other l/O Devices
`
`/ 50
`
`/ 52
`
`7
`
`7
`
`Dis la
`
`p y
`
`54
`External Memory /
`
`LAN
`
`'
`
`" "
`
`20
`/
`Local Sen/er
`E = Appl. #1
`F = Appl. #2
`G = Appl. #3
`
`WAN
`
`Etc.
`
`36
`Service /
`
`
`-
`
`/ 40 _ -
`I
`Microprocessor <:> :
`E
`E
`A
`Internal
`C
`Memory “All; E
`
`ii / 44
`
`/ 106
`
`Query
`Unload
`
`/ 100
`
`“ / 104 / 110
`Main
`
`Program Control
`
`: Timer 2
`
`F i ure 4
`
`/ 10s
`
`Timer 1
`
`Petitioner Apple Inc. - Ex. 1011, p. 3
`
`

`
`US. Patent
`
`'
`
`Feb. 10, 1998
`
`Sheet 3 of 5
`
`5,717,604
`
`160 /
`
`CHKTIME
`
`T|MER1
`
`TIMERZ
`
`IDLETIME
`
`CLOSINTIME
`
`IDLEMESSAGE
`
`166
`Reset Timer1 and
`Timer2 /
`
`V
`
`1
`Wait CHKTIME / 68
`
`Figure 5
`
`170
`
`174
`Start T|MER1 and /
`TIMER2
`
`176
`
`184
`
`No
`Timer2>=
`CLOSINTIME? __
`
`T|MER1 >=
`jDLETIME‘?
`
`186 \
`
`Close Appl'n
`
`Yes / 1
`Display Idle
`Message
`
`<
`
`Return
`
`)
`
`Petitioner Apple Inc. - Ex. 1011, p. 4
`
`

`
`U.S. Patent
`
`Feb. 10, 1998
`
`Sheet 4 of 5
`
`5,717,604
`
`{
`
`Start
`
`)
`
`/ 240
`
`USERNAME
`TIMER
`
`Fig ure 6
`
`Recrzord / 243
`USERNAME
`
`Start USERNAME / 250
`Timer
`
`252
`
`;,
`
`.
`
`User
`Terminate
`Appl‘n?
`Yes
`
`254 /
`Stop USERNAME
`Timer
`
`Petitioner Apple Inc. - Ex. 1011, p. 5
`
`

`
`US. Patent
`
`Feb. 10, 1998
`
`Sheet 5 of 5
`
`5,717,604
`
`Start / 300
`
`312
`
`314
`
`Copies Being
`
`/310
`
`k
`
`USER1 Priority
`
`OTHERUSER
`Priority
`OTHERUSER
`Status
`
`Max Users
`
`.
`
`F lgure 7
`
`SER1=
`OTHERUSER
`Priority and
`Inactive?
`
`316
`
`r
`
`\ Compare USER1
`Priority to
`OTHERUSER
`Priority and Appl’n
`Status
`
`318
`
`322 \ Identify and Close
`OTHERUSER
`
`V
`
`326 \ Grant USER1
`Access
`
`4
`7
`
`End
`
`Petitioner Apple Inc. - Ex. 1011, p. 6
`
`

`
`5,717,604
`
`1
`NETWORK MONITORING SYSTEM FOR
`TRACKING, BILLING AND RECOVERING
`LICENSES
`
`BACKGROUND OF THE INVENTION
`
`2
`other words, multi-tasking operating systems increase
`license requirements and costs in a network having a shared
`license pool.
`Therefore, a network monitoring system which reduces
`license cost for a network of computers running multi
`tasking operating systems is desirable. Further, a network
`monitoring system which optimizes use of licenses in a
`shared license pool is desirable.
`In a network having a shared license pool, a ?xed number
`of licenses are available at one time. Problems occur when
`a large number of users tend to desire access to an applica
`tion at a common or prime time. For example, a shared
`license pool may have one license for every ?ve machines
`for a word processing application. A large number of users
`may desire access to the word processor at the same time, for
`example at the end of the month to prepare monthly reports.
`Because only a ?xed number of licenses are available, some
`users will be unable to access the desired application during
`the prime time. Even a manager who may need access to the
`wordprocessing application more than some of his employ
`ees is denied access if the ?xed number of licenses in the
`shared license pool are being used. The only way to alleviate
`this problem is to purchase additional license copies which
`increases costs. Therefore, a network monitoring system
`which addresses these problems is also desirable.
`As the trend of having a large number of users on a
`network increases, processing power of a service provider
`providing access to user applications on the network will
`become more scarce. Typically the service provider provid
`ing access to the user application performs the processing
`and the user operates in a terminal mode. In essence, the
`user’s processor only executes terminal processing related to
`input and output of already-processed data from the service
`provider. Competing uses of the service provider such as
`sharing large common ?les, sharing meter?les, and running
`more complex applications are also competing for process
`ing time/power.
`As the number of users increases, the processing demand
`will likewise increase and the service provider will require
`more and more processing power. Therefore it is desirable to
`decrease demands on the service provider’s processor to
`allow the service provider to focus on processing data or
`user applications which cannot be performed by the user.
`SUMMARY OF THE INVENTION
`A network monitoring system according to the invention
`includes a computer with a processor for running a multi
`tasking operating system capable of having both active and
`inactive windows. The computer is connected to at least one
`of a server and a service which provides said computer
`access to a user application subject to a license restriction.
`The user application is associated with one of said active and
`inactive windows. When said user application is associated
`with one of said active windows, said user application is
`executed by said processor. A display, coupled to said
`processor, displays a user interface of said operating system.
`A user prompting device, associated with said processor,
`said display and said user application, prompt a user when
`said one of said active and inactive windows associated with
`said user application has been inactive for a period greater
`than a ?rst predetermined period.
`According to another feature of the invention, a closing
`device, associated with said processor and said user
`application, closes said user application when said one of
`said active or inactive windows associated with said user
`application has been inactive greater than a second prede
`termined period.
`
`10
`
`1. Technical Field
`This invention relates to computers, and more
`particularly, to a network monitoring system for tracking,
`billing and recovering licenses for computers connected to a
`network and running multi-tasking operating systems.
`2. Background of the Invention
`As a result of intense competition and innovation, per
`sonal computers (PCs) have become more versatile by
`evolving from a single-tasking, stand-alone device to a
`single-tasking network device to a multi-tasking network
`device. As a stand-alone device, PCs run an operating
`system, such as DOS®, which is capable of executing only
`one application at a time (“single-tasking”). Every applica
`tion that the user intends to run has to be installed on the
`stand-alone PC. The stand-alone PC runs one application at
`a time and starts and stops each application in succession.
`Therefore, stand-alone PCs have a 1:1 ratio of PCs to
`licenses. For example, if the PC user desires ?ve
`applications, such as word processing, terminal emulation, a
`spreadsheet, graphics, and a database, the user requires ?ve
`licenses, in other words, a license copy for each application
`installed on the stand-alone PC.
`Local area networks (LAN s) allow the interconnection of
`multiple PCs. Each PC shares disk space, ?les, printers, and
`other I/O devices with a network server. However, the PCs
`still run a single-tasking operating system and, therefore,
`still run only one license application at a time. Using the
`network server, however, the applications are shared by the
`multiple PCs (“shared license pool”). Not every PC needs to
`have each application installed locally at the same time nor
`is a license copy required for each PC.
`Because the PCs are still single-tasking, not every PC
`needs to access every application all of the time. The
`applications are available on the network server when they
`are needed. Therefore, depending on the statistical demand,
`a single copy of an infrequently used application is shared
`among many users. Even the most popular application does
`not require a license for every user. The bene?ts of the
`shared use of the applications on the server allow the ratio
`of PCs to licenses to increase signi?cantly, for some appli
`cations a ratio 15:1 (?fteen PCs accessing the server to one
`license available on the network server) are typical. This
`shared use of applications resulted in a cost saving because
`license cost is typically based upon the number of concur
`rent users.
`When multi-tasking operating systems, such as
`Vtfrndows®, were introduced, the prior cost savings of
`sharing applications on the network server were reduced. A
`55
`PC running a multi-tasking operating system is capable of
`running multiple applications at a time. Therefore, a single
`PC user can tie up multiple licenses. Network PCs running
`a multi-tasldng operating system can still access the shared
`license pool on the network server. However, theoretically,
`every PC can access every application at the same time.
`Therefore, a single user could tie up multiple applications on
`the server and reduce access to these by other users.
`The effect of multi-tasking operating systems on shared
`license pools caused the industry to move backwards from
`the higher ratios towards the 1:1 ratio of PCs to licenses
`which was the case for stand-alone single-tasking PCs. In
`
`65
`
`25
`
`35
`
`45
`
`50
`
`Petitioner Apple Inc. - Ex. 1011, p. 7
`
`

`
`5,717,604
`
`10
`
`20
`
`25
`
`35
`
`3
`According to still another feature, a check device, asso
`ciated with said processor, said user prompting device, and
`said closing device, periodically enables said user prompting
`device and said closing device based on a third predeter
`mined period shorter than said ?rst and second predeter
`mined periods.
`According to still another feature of the invention, an
`identi?cation (ID) device, associated with said computer,
`generates an access request including a computer ID to
`access said user application and a termination request to
`terminate said user application. An application usage storing
`device, coupled to said lD device, stores said computer ID
`and user startup and termination data based on said access
`and termination requests for said computer. Abilling device,
`associated with said application usage storing device, gen
`erates billing for said computer for use of said user appli
`cation based upon said user startup and termination data.
`According to still another feature of the invention, a
`plurality of computers each include a processor for execut
`ing a multi-tasking operating system capable of having
`active and inactive windows. The plurality of computers are
`connected to at least one of a server and a service which
`provides access to said user application. A network monitor,
`coupled to said plurality of computers, for provides a ?rst
`predetermined number of users access to said user applica
`tion. A storing device, associated with said network monitor,
`for stores a user identity and a user priority for each of said
`?rst predetermined number of users. A comparing device,
`associated with said network monitor and said storing
`device, compares a user priority of a new user requesting
`access to said user application to said user priorities stored
`in said storing device when said ?rst predetermined number
`of users are currently accessing said user application.
`According to still another feature, a closing device,
`coupled to said comparing device, closes said user applica
`tion for one of said ?rst predetermined number of users if
`said user priority of said new user is higher than the user
`priority of said one of said ?rst predetermined number of
`users.
`According to another feature, a closing device, coupled to
`said comparing device, for closing said user application for
`one of said ?rst predetermined number of users if said user
`priority of said new user is the same as said user priority of
`said one of said ?rst predetermined number of users and if
`said user application of said one of said predetermined
`number of users is associated with an inactive window.
`According to another feature, an access granting device,
`coupled to said comparing device, grants said new user
`access to said user application.
`Other objects, features and advantages will be readily
`apparent from the speci?cation, drawings and accompany
`ing claims.
`BRIEF DESCRIPTION OF THE DRAWINGS
`The various advantages of the present invention will
`become apparent to those skilled in the art after studying the
`following speci?cation and by reference to the drawings in
`which:
`FIG. 1 is a diagram illustrating a stand-alone personal
`computer (PC) according to the prior art;
`FIG. 2 is an electrical schematic illustrating di?erent
`interconnections of PCs, servers, and a service provider via
`local area networks and wide area networks according to the
`prior art;
`FIG. 3 is an electrical schematic of a personal computer
`for executing procedures associated with the network moni
`toring system;
`
`4
`FIG. 4 is a block diagram illustrating a license recovering
`procedure for the network monitoring system according to
`the present invention which can be run on the PC, server or
`service provider of FIG. 3;
`FIG. 5 is a ?ow chart depicting the license recovering
`system of FIG. 4 and its associated data structure;
`FIG. 6 is a flow chart depicting a real-time license billing
`procedure for the network and its associated data structure;
`and
`FIG. 7 is a ?ow chart of a license priority procedure and
`its associated data structure.
`
`DETAILED DESCRIPTION OF THE
`INVENTION
`
`I. Background and Hardware System Description
`
`A. Stand-Alone PC.
`In FIG. 1, a PC 10 running a single-tasking operating
`system according to the prior art is illustrated. PC 10 is a
`stand-alone computer which is not connected to a network.
`PC 10 includes a microprocessor, memory, a display. and an
`input/output (I/O) interface (not shown in FIG. 1). PC 10
`runs the single-tasking operating system, such as DOS®,
`which is capable of executing only one application at a time.
`Every application which the user desires must be installed in
`internal or external memory of PC 10. PC 10 runs only one
`application at a time, each starting and stopping in succes
`sion. Therefore, PC 10 requires one license for every appli
`cation which it runs.
`2. PC Running A Single-Tasking Operating System
`With reference to FIG. 2, PC 10' can be connected to a
`local area network (LAN) 14 via a network bus 16 in a
`conventional manner. PC 10' can share disk space, ?les,
`printers, applications, or other devices, with a network
`server 20. Because PC 10' runs a single-tasking operating
`system, such as DOS®, PC 10' can still only run one
`application at a time. However, PC 10‘ can be connected to
`network server 20 and share applications with server 20. PC
`10' no longer needs to have every application installed
`locally as with the stand-alone PC 10 in FIG. 1.
`3. PC Running A Multi-Tasking Operating System
`Other PCs 22 coupled to LAN 14 in a conventional
`manner run a multi-tasking operating system, such as Win
`dows®. Each of these PCs 22 is capable of running more
`than one application at a time, unlike PC 10' which must run
`only one application at a time. Typically the multi-tasking
`operating system allows one or more active windows (or
`application) which is/are cln'rently being executed and mul
`tiple inactive windows which are idle. As can be
`appreciated, PC 22 can more readily exhaust the shared
`license pool of the server 20 because the user can open
`multiple licensed application at once. Each PC 20 requires
`a license copy for each application whether the application
`is associated with the active or inactive windows.
`Server 20 can, in turn, be coupled to a wide area network
`(WAN) 30, such as the Internet, which can provide addi
`tional applications to the PCs 10 and 20. Altemately, a PC
`34 running a single- or multi-tasking operating system can
`be coupled directly to WAN 30 which provides access to a
`service provider 36 and other LANs 38. Still other con?gu
`rations will be apparent to skilled artisans.
`In FIG. 3, PC 22 which runs a multi-tasking operating
`system is illustrated in further detail. PC 22 includes a
`microprocessor 40, internal memory 44, and an input/output
`(I/O) interface 46. PC 22 includes a keyboard 50, a display
`
`45
`
`50
`
`55
`
`65
`
`Petitioner Apple Inc. - Ex. 1011, p. 8
`
`

`
`5,717,604
`
`10
`
`25
`
`5
`52, external memory 54, such as a hard drive, tape drive,
`CD-ROM, etc. and other input/output (I/O) devices 56 such
`as a mouse. PC 22 is connectable to a local server 20 via
`LAN 14 and to a service provider 36 via WAN 30 in a
`conventional manner.
`
`II. License Recovering Procedure
`
`In FIG. 4, a functional diagram of a license recovering
`procedure 100 for the network monitoring system is illus
`trated. License recovering procedure 100 is preferably
`implemented as software stored in memory 44 (and/or
`memory 54) and executed by microprocessor 40 which runs
`a multi-taslting operating system such as Windows®. As can
`be appreciated, other multi-tasking operating systems can be
`employed. Alternately, license monitoring procedure 100
`can be implemented in an electronic circuit using discrete
`components, stored in ?rmware, etc. License recovering
`procedure 100 includes a main program control 104, que
`ryunload module 106, Timerl module 108 and TimerZ
`module 110.
`Queryunload module 106 checks the unload mode of an
`application. In other words, when the application is being
`exited, queryunload module 106 checks the propriety of the
`method of exiting the application. The license recovering
`procedure 100 allows the user to unload (or quit) if the user
`employs the built-in procedures of the application and/or if
`the multi-tasking operating system is being closed.
`Otherwise, queryunload event 106 displays a message using
`the user interface to close the running application ?rst.
`Timerl module 108 checks the instance of a current active
`window every chktime seconds. If the current active win
`dow is not “our” window (in other words, the application
`being monitored is inactive), a timer is incremented. If the
`timer exceeds idletime, an idlemessage is displayed and the
`timer is reset. If the current window is “our” window (in
`other words, the application is active), the time is reset.
`Timer2 module 110 checks the instance of the current active
`window every chktirne seconds. If the current active win
`dow is not “our” window, a timer is incremented. Ifthe timer
`exceeds closintime, license recovering procedure 100 closes
`the application. If the current window is “our” window, the
`timer is reset.
`As can be appreciated, one or more applications can be
`monitored. Each application to be monitored would be
`associated with a running copy of the license recovering
`procedure 100.
`In FIG. 5, a ?ow diagram illustrates operation of Tirnerl
`and Timer2 modules 106 and 108 of license recovering
`procedure 100 using a ?ow diagram 150 and an associated
`data structure 160. Skilled artisans can appreciate that
`Timerl and Timer2 modules 106 and 108 can be event
`driven instead of ?ow driven. However, the operation will be
`analogous. Data structure 160 includes a chktime variable, a
`Timerl variable, a TimerZ variable, an idletime variable, a
`closintime variable, and an idlemessage variable.
`License recovering procedure 100 begins at step 164
`where control determines whether “our” application is open.
`If not, control loops until “our” application is open. If “our”
`is open, control proceeds to step 166 where Tirnerl and
`Timer2 are reset. At step 168, control waits a predetermined
`period set by chktime variable. At step 170, control deter
`mines if “our” application is idle. If not, control returns to
`step 164. If “our” application is idle, control continues with
`step 174 where the Timerl and Timer2 variables are started.
`Skilled artisans can appreciate that a single timer can be
`employed if desired.
`
`6
`Control continues with step 176 where the Tirnerl vari
`able is compared to the idletime variable. If the Timerl
`variable exceeds the idletime variable, control displays an
`idlemessage such as “Be considerate to others and close this
`idle application”, at step 180. As can be appreciated, the
`system operator can provide other messages as desired If
`the Timerl variable does not exceed the idletime variable,
`control proceeds with step 184 where control determines
`whether the Timer2 variable is greater than or equal to
`closintime. If the Timer2 variable exceeds the closintime
`variable, control closes “our” application at step 186. If not,
`control returns.
`The following sections detail a speci?c implementation of
`the present invention for PCs operating with Windows®:
`
`I.
`
`License Monitoring and Recovering Code Structure
`
`A. Declarations
`
`declare Windows ® API functions
`declare Windows ® API Constants
`declare program global variables
`B. Fumtions
`
`Functions are speci?cally called in.
`Function IsSucces
`check program return code after trying to connect to
`a network drive and return status
`Function DisSuccess
`check program return code after trying to disconnect
`from a network drive and true status
`Function Drive_i.n_use
`check the active task list for any program using
`this drive and return true or false
`‘
`
`C. Events
`
`35
`
`Events can happen at any time
`1.
`QueryUnload
`
`check unload mode
`if attempting to unload from the main program, ok
`if attempting to unload because windows is exiting, ok
`if attempting to unload from anywhere else, display
`message to close the timing application ?rst.
`2. Tmerl
`
`every chktime seconds, get the instance of the current
`active window
`if current active window is not ‘our’ window
`increment timer interval
`checktosee iftheelapsedtimeisgraterthan
`idletime
`if so, display idlemessage and set the dialog
`to modal if ismodal is true
`reset the timer interval and continue
`if current window is ‘our’ window, reset the timer
`interval and continue
`3. Timer2
`
`every chktime seconds, get the instance of the current
`active window
`if current active window is not ‘our’ window
`increment timer interval
`ehecktoseeiftheelapsedtimeisgreaterthan
`closintime
`if so, send nnssage to the application to close
`reset the timer interval and continue
`if current window is ‘our’ window, reset the timer
`interval and continue
`
`D. Main
`
`disable timer events; Timerl and Timer2
`initialize local variables
`?nd this program window and hide it from the windows
`task list
`set up the initialization ?le string based on the program
`path
`
`45
`
`50
`
`55
`
`65
`
`Petitioner Apple Inc. - Ex. 1011, p. 9
`
`

`
`5,717,604
`
`7
`-continued
`
`verify that the initialization ?le is a valid ?le
`process the command line, checking for errors
`parse the command line string for the application name and
`optional program startup parameters
`check for the special command line word “ABOUT’
`if “ABOUT”, open the diagnostic dialog box
`wait to close dialog and then end program
`open the initialization ?le
`read the service variables;
`drive
`the drive letter to map the serve (share)
`service the service (share) to attach to
`program the program to run
`dummyl username
`dummy2 password
`ismodal characteristic of idle message dialog box
`build the program string from program and drive
`build usemame and password string from dummyl and
`dummy2 if speci?ed
`check to see if we are already connected to the service
`read the program setup variables;
`setupgpgm
`the setup program to run to install the
`application
`the ?le to check for to indicate if the
`application is installed
`the disk to install the application on
`appnstldisk
`appnstlspace the required disk space to install this
`application
`check to see if the application is installed by checking for
`
`appnstl?le
`
`8
`-continued
`
`if the current users equals maxusers, check for an
`alternate license ?le altwho?le
`if an alternate is speci?ed
`connect the alternate license server to
`altwhoservic' e
`verify the connection by calling function
`IsSuccess
`if successful continue
`if not,
`display message indicating no available
`licenses
`write entry in the meter?le
`end program
`read the altwho?le to check if current users is less than
`maxusers
`if so, continue
`if not
`display message indicating no available
`licenses
`write entry in the meter?le
`attempt to disconnect the drive
`verify disconnection by calling DisSuccess
`end program
`otherwise update the who?le or altwho?le and
`continue
`if we are not connected, try to connect to the service
`verify the connection by calling ftmction IsSuccess
`if successful continue
`if not
`display message indicating connection failure
`write entry in the meter?le
`end program
`if we connect,
`play soundl
`write entry in meter?le indicating NODE, application
`name, status and time
`change default drive and directory to altworkingdir if
`speci?ed
`enable timer events; Timerl and Timer2
`try to run the application
`if not
`generate message
`disconnect drive
`end program
`shell the application and keep track of it‘s instance
`wait for the application program to exit
`if the program has exited, check for spawnandend
`if spawnandend, get the spawned windows instance
`and keep track of it
`disable timer events; Timerl and Timer2
`play sound2
`call function Drive___in_use to see if any other program is
`using this drive
`ifthedriveis inusebyanyotherprogram
`if no other copies of this application are still rlmning, up
`date the who?le or altwho?le
`update the meter?le
`end program
`if no other application is using the drive, attempt to dis
`connect it
`call function DisSuccess to verify disconnection
`play sound3
`update the who?le or altwho?le
`update the meter?le
`end the program
`
`11. INI File
`
`The software for license recovering procedure 100 checks
`for an application name on the command line. Command
`line parameters can be used after the application name. For
`example:
`Command Line: SEAMSI‘Rs Excel C:\myclata.xls
`Command Line: SEAMSTRS Word
`Where SEAMSI'RSTM or SEAMSTRESSTM is the command
`line name of the network monitoring system The applica
`tion name on the command line should match one of the
`
`10
`
`15
`
`20
`
`25
`
`35
`
`45
`
`55
`
`65
`
`soundl
`
`sound2
`
`sound3
`
`spawnandend
`
`altworkingdir
`
`in not installed
`if so,
`check for the setup program setuppgm and
`set the main program to be the setup program
`verify enough free space on drive appnstldisk
`by checking against size appnstlspace
`if not end the program
`-
`if installed, read the miscellaneous variables
`meter?le
`the ?le used to log the connect,
`disconnect, terminate and idle times
`the sound played when a drive is
`connected to the service
`the sound played when an application
`terminates
`the sound played when the drive is dis
`connected ?om the service
`a parameter to indicate that the application
`will launch another program and
`immediately terminate
`the path of an alternate working directory
`for the application
`the allowed application idle time
`the frequency of the events; Timerl and
`Timer2
`the message displayed when the application
`has been idle longer than idletime
`the allowed maximum idletime before the
`application is automatically closed
`the maximum number of users licensed to
`run the application
`the name of the license ?le that will
`keep track of who and how many users are
`using the application
`the drive letter of an alternate who ?le
`the ?le name of an alternate license ?le
`the name of the service containing the
`alternate license ?le
`close the initialization ?le
`read the DOS environment variable NODE
`check for the license ?le who?le
`see if the ?le who?le exists
`if not, create the ?le and write the sections;
`application name and maxusers
`if so, check to see if this application name is
`registered
`if this application name is not registered,
`register it
`if it is registered, update maxusers
`read the application name section, get max'users
`and the number of current users
`see if this NODE is registered
`
`idletime
`chktime
`
`idlemessage
`
`closintime
`
`maxusers
`
`who?le
`
`alwhodrive
`alwho?le
`alwhoservice
`
`Petitioner Apple Inc. - Ex. 1011, p. 10
`
`

`
`application names in the .INI ?le. The .INI ?le speci?es the
`application, services, drive letter, program, install ?le, set-up
`program, disk space, username, password, sound ?les, meter
`log ?le, timer interval, idletime, idlemessage and/or message
`type
`For example. the .INI ?le can have the following format:
`
`A. INI FILE EXAMPLE
`[MSInfU]
`Drive=jz
`service=\\cwsrv1\word60a
`dmnmyl=testuser
`dummy2=testme
`dummy3=test
`pmgram=\msapps\msinfo\msifo.exe
`Appnstl?le=c:\joesch.rnoe
`SetupPgm=\winwword\setup.exe
`Appnstlspace=1000
`Sound1=c:\windows\tada.wav
`Sound2=c:\windows\chord.wav
`Souud3=c:\windows\chimes.wav
`Meterfile=zapplictrrmtr
`IsMsgM0da1=false
`chktime=60
`idletime=l800
`idlemessage=“Please be considerate of others.”
`SpawnandEnd=YES
`MaxUsers=l0
`WhoFile=z:\who?le.who
`AltWhoDrive=0z
`AltWhoService=\\fesrv2\wingr-p
`AltWhoFile=\a1t?le.who
`[Word]
`Driver-j:
`service=\\cwsrvl\word60a
`
`. . . etc . . .
`
`[Excel]
`
`. . . etc . . .
`
`[PowerPoint]
`
`. .
`
`. etc . . .
`
`B. 1N1 File Parameters
`1. Appname
`The ?rst Keyname is Appname which is preferably a one
`word name for the application which corresponds to the
`application name speci?ed on the command line. The App
`name will appear as the title on generated message boxes.
`For example, [MSInfo].
`2. Drive
`Drive speci?es the drive letter to map to the ?le service
`(share). This must be a single letter less than or equal to last
`drive (in CONFIGSYS) followed by a colon (t). For
`example, Drive=J.
`3. Service
`Service speci?es the ?le service (share) name. It should be
`in \\server\service format. For example, service:
`\\cwsrvl\word60. The service can be server 20, service
`provider 36, or any other network with a shared license pool.
`4. Dummy
`Dummyl speci?es the Username for service connection.
`This is used for Pathwork