Class store schema

Abstract

A schema that facilitates the centralized management and deployment of applications, components and services across a computer network. Centralized class stores are provided under policies associated with a directory container such as a site, domain or organizational unit. Class stores include definition, state and location information for applications and components, such that applications and components are centrally available as needed. For example, via the class store, updates to components or applications for users under an organizational unit are performed once in a centralized location, whereby users or machines may automatically obtain new versions of applications as they become available, or software implementations as needed from a centralized repository. Class stores may be configured to contain packages of component and application information according to functional areas, level of security access, or other criteria as determined by an administrator. Component categories (e.g., spreadsheet, word processor, and so on) may also be maintained, whereby a suitable application may be located by its function. For customized administration and programmatic query or installation of specific components and packages, the class store also includes a manager object that offers a set of interfaces and APIs.

Claims

What is claimed is:

1. A computer-readable medium having stored thereon a data structure, comprising,

(a) a first data field containing data representing an identity of an executable software module;

(b) a second data field containing data representing network deployment state information of the executable software module in the first data field;

(c) a third data field containing data representing network location information for the executable software module in the first data field; and

if the network deployment state; information in the second field indicates that the executable software module identified in the first field is to be made available to a user of a client machine of the network, making the executable software module available to the user when needed, independent of which client machine the user is using, by automatically accessing the network location information and automatically installing the executable software module on the client machine based on the location information.

2. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment information comprises state information indicative of whether the application is assigned to the policy recipient.

3. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises state information relating the executable software module to another executable software module.

4. The computer-readable medium having stored thereon the data structure of claim 3 wherein the deployment state information indicates that the other executable software module is to be overwritten upon installing the executable software module.

5. The computer-readable medium having stored thereon the data structure of claim 3 wherein the deployment state information indicates that the other executable software module is to be uninstalled in conjunction with installing the executable software module.

6. The computer-readable medium having stored thereon the data structure of claim 1 wherein the executable software module is advertised to the user as being available for execution on the client machine prior to installing the executable software module.

7. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of whether a patch is to be installed for the executable software module.

8. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of a hardware processor compatible with the executable software module.

9. The computer-readable medium having stored thereon the data structure of claim 8 wherein the hardware processor information is used to determine whether the executable software module is compatible with the client machine.

10. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of an operating system compatible with the executable software module.

11. The computer-readable medium having stored thereon the data structure of claim 10 wherein the operating system information is used to determine whether the executable software module is compatible with the client machine.

12. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of class identifiers implemented by the executable software module.

13. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of file types handled by the executable software module.

14. The computer-readable medium having stored thereon the data structure of claim 13 wherein the information indicative of file types comprises a list of file extensions.

15. The computer-readable medium having stored thereon the data structure of claim 1 wherein the network location information comprises information indicative of a network path.

16. The computer-readable medium having stored thereon the data structure of claim 15 wherein the network path information provides a network location where application advertisement script information is present.

17. The computer-readable medium having stored thereon the data structure of claim 15 wherein the network path information provides a network location where application advertisement binaries are present.

18. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of another executable software module to be upgraded by the executable software module.

19. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of another executable software module that can upgrade the executable software module.

20. The computer-readable medium having stored thereon the data structure of claim 19, wherein the deployment state information further comprises information indicative of the manner of upgrade.

21. The computer-readable medium having stored thereon the data structure of claim 20 wherein the information indicative of the manner of upgrade indicates that the upgrade will overlay the executable software module during installation of the other executable software module.

22. The computer-readable medium having stored thereon the data structure of claim 20 wherein the information indicative of the manner of upgrade indicates that the upgrade will uninstall the executable software module before installation of the other executable software module.

23. The computer-readable medium having stored thereon the data structure of claim 22 wherein the deployment state information comprises information indicative of a time when the executable software module was deployed.

24. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of a time when the executable software module had its deployment state changed.

25. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of whether the executable software module is to be orphaned on the user's machine.

26. The computer-readable medium having stored thereon the data structure of claim 1 wherein the deployment state information comprises information indicative of a uniform resource locator providing a location where further information can be found about this executable software module.

27. A computer-readable medium having stored thereon a data structure, comprising:

a package capable of being deployed to a policy recipient;

an object class container including registration information corresponding to the package:

component categories information of the object class, including deployment state information corresponding to the package and network location information corresponding to a location of the package, and

if the deployment state information indicates that the package is to be made available to the policy recipient, deploying the package to the policy recipient when needed by automatically accessing the network location information and automatically installing the package from the network to the policy recipient machine based on the network location information.

28. The data structure of claim 27 wherein the package includes an application program.

29. The data structure of claim 27 wherein the package includes a set of binary component implementations.

30. The data structure of claim 27 wherein the package includes a standalone component.

31. The data structure of claim 27 wherein the package includes version information.

32. The data structure of claim 27 wherein the deployment state information includes data indicating that the package is published to at least one policy recipient.

33. The data structure of claim 27 wherein the deployment state information includes data indicating that the package is assigned to at least one policy recipient.

34. In a computer network having a plurality of client machines and a plurality of policy recipients comprising client users or client machines, a method comprising:

associating policy data with a policy recipient, the policy data including at least one class store containing application deployment information corresponding to the policy recipient, the application deployment information including an identity of at least one executable software module and a state of deployment therefor; and

managing which executable software is available for use on a particular client machine based on the policy data by:

1) accessing the at least one class store to determine the state of deployment information for a selected executable software module identified therein;

2) comparing an actual state of deployment of the selected executable software module on the client machine to the state of deployment information for the selected executable software module determined from the at least one class store; and

3) automatically configuring the client machine so that the actual state of deployment of the selected executable software module corresponds to the state of deployment information in the at least one class store.

35. The method of claim 34, further comprising, evaluating access control information associated with the at least class store.

36. The method of claim 34, wherein the policy recipient is a user, and wherein the policy data associated with that user makes at least one application program available to the user independent of which client machine in the network the user is using.

37. The method of claim 34, wherein automatically configuring the client machine occurs for the user each time the user logs onto that client machine.

38. The method of claim 34, wherein the policy recipient is a client machine, and wherein the policy data associated with that client machine makes at least one application program available to any user of the client machine.

39. The method of claim 34, wherein accessing the at least one class store indicates that the selected executable software module should not be installed on the client machine, wherein comparing an actual state of deployment indicates that the selected executable software module is installed, and wherein configuring the client machine includes uninstalling the selected executable software module from the client machine.

40. The method of claim 34, wherein configuring the client machine includes writing data related to the selected executable software module to a database maintained at the client machine.

41. The method of claim 40, wherein writing data to the database includes modifying a registry on the client machine.

42. The method of claim 34, wherein the selected executable software module comprises an application program, wherein configuring the client machine includes writing data related to the application program to the client machine to advertise the application as available for execution on the client machine regardless of whether it is actually installed on the client machine, and, if the application is later requested to be executed but is not installed for execution, automatically installing and executing the application on the client machine.

43. The method of claim 34, wherein configuring the client machine includes publishing the selected executable software module to the client machine by maintaining information on the client machine for automatically installing the selected executable software module on the client machine and executing it if later needed.

44. The method of claim 34, wherein accessing the at least one class store indicates that the selected executable software module should be patched on the client machine, and wherein configuring the client machine includes patching the selected executable software module on the client machine.

45. The method of claim 34, wherein accessing the at least one class store indicates that the selected executable software module should be overwritten on the client machine with another version thereof, and wherein configuring the client machine includes overwriting the selected executable software module on the client machine with the other version.

46. The method of claim 34, wherein accessing the at least one class store indicates that the selected executable software module should be uninstalled and replaced with another version thereof on the client machine, and wherein configuring the client machine includes uninstalling the selected executable software module and thereafter installing the other version of the selected executable software module on the client machine.

47. The method of claim 34, further comprising, receiving data corresponding to a class identifier at the client machine, querying the at least one class store to attempt to find executable software module deployment information associated with the class identifier, and if the class store includes deployment information for that class identifier, installing the executable software module based on the deployment information for that class identifier.

48. The method of claim 34 further comprising, receiving data corresponding to a file type at the client machine, querying the at least one class store to attempt to find executable software module deployment information associated with the file type, and if the class store includes deployment information for that file type:

a) installing the executable software module based on the deployment information for that file type in the class store, and

b) executing the executable software module.

49. The method of claim 34, wherein the deployment information in the class store further includes installation information of the selected executable software module, wherein accessing the at least one class store indicates that the selected executable software module should be installed on the computer system, wherein comparing the actual state of deployment indicates that the selected executable software module is not installed, and wherein configuring the computer system includes installing the selected executable software module on the computer system based on the installation information.

50. A computer-readable medium having computer-executable instructions for performing the method of claim 34.

51. The method of claim 34, wherein the selected executable software module comprises an application program, and wherein configuring the computer system includes, advertising the application by making the application appear available for execution on the computer system without installing the selected executable software module onto the computer system until needed.

52. In a computer network, a method comprising:

associating a class store with a policy recipient, the class store containing an identity of an executable software module and network location information of the executable software module;

receiving a request, at a client machine having a relationship with the policy recipient, to execute the executable software module;

querying for information, in a system to registry of the client machine, for executing the executable software module, and if the information needed to execute the executable software module is not found:

1) querying the class store for information corresponding to the executable software module;

2) installing the executable software module based on the network location information in the class store; and

3) executing the executable software module.

53. The method of claim 52 wherein the policy recipient corresponds to the client machine.

54. The method of claim 52 wherein the policy recipient corresponds to a user logged onto the client machine.

55. The method of claim 52 wherein receiving a request includes receiving a class identifier.

56. The method of claim 52 wherein receiving a request includes receiving file type data.

57. The method of claim 52 wherein installing the executable software module based on the network location information in the class store comprises, downloading at least one file from a network source.

58. In a computer network having a plurality of client machines and a plurality of policy recipients comprising client users or client machines, a system comprising:

a policy object, the policy object containing a class store, the class store containing application deployment information including an identity of an executable software module a state of deployment for the executable software module, and network location information for the executable software module;

a selected client machine having a relationship with a policy recipient that is associated with the policy object, the client machine having access to the policy object; and

executable code on the client machine that receives a request corresponding to execution of the executable software module, wherein based on the request, the executable code:

1) accesses the class store to obtain the state of deployment information for the executable software module;

2) determines from the state of deployment information in the class store whether the policy recipient is able to execute the executable software module, and if so, automatically installs and executes the executable software module based on the network location information in the class store.

59. The system of claim 58 wherein the selected client machine corresponds to the policy recipient and the policy object comprises a machine policy object.

60. The system of claim 58 wherein a user logged onto the selected client machine corresponds to the policy recipient.

61. The system of claim 58 herein the executable code on the client machine comprises operating system code.

62. The system of claim 58 wherein the request corresponding to execution of the executable software module includes class identifier data.

63. The system of claim 58 wherein the request corresponding to execution of the executable software module includes file type data.

Description

FIELD OF THE INVENTION

The invention relates generally to computer systems, and more particularly to the management and deployment of applications, components and services across a computer network.

BACKGROUND OF THE INVENTION

Lost productivity at employees' computer desktops is a major cost for corporations, often resulting from user errors such as removing a software component or using an old application rather than an enterprise-specified one that is improved, secure and/or compatible with others. Productivity is also lost when a desktop is too complex, such as when the desktop has too many non-essential applications and features thereon. Much of the expense of administering distributed personal computer networks is spent at the desktop, performing tasks such as fixing the applications and settings that the user has incorrectly or inadvertently modified.

At the same time, a significant amount of the information needed to administer a network is haphazardly handed down by enterprise management to an administrator who must then manually implement changes to the network based on the information. For example, management may decide that everyone in the personnel department should use a particular word processor, whereby the administrator manually installs that word processor on the computers in the personnel department. Similarly, management may decide that employees spend too much time browsing the Internet, whereby the administrator receives a memorandum specifying that only certain groups such as the research group and management group should have Internet browsers installed on their machines. In addition to having to uninstall browsers and hope (or regularly check) that non-approved users do not reinstall the browser, such a policy causes problems when multiple users share the same computer.

More complex application deployment problems arise with upgrades to applications, patches, and the ability of some applications to handle multiple types of files and class IDs. Other problems result from differing policy needs, e.g., all users are to receive the same electronic mail program and word processing program, but only a subset of an enterprise's users will be able to receive a spreadsheet program, and then only those user's who want it. As can be readily appreciated, a significantly large number of such policy permutations may exist with respect to deploying applications in an enterprise, however no schema for and tracking and managing application deployment has heretofore existed.

SUMMARY OF THE INVENTION

Briefly, the present invention provides a class store schema for facilitating the management and deployment of applications, components and services across a computer network. Centralized class stores are provided, which include state, definition and location information for applications and components, such that applications and components are made centrally available as needed. For example, via the class store, updates to components or applications are performed once in a centralized location, whereby users may automatically obtain new versions of applications as they become available. Similarly, if a software implementation (e.g., object class) is needed but is not available in the local registry, the system looks in the class stores for a suitable implementation. In this manner, the COM libraries, Shell, and Internet Explorer automatically use the class store to dynamically install missing applications or components.

In a described embodiment, the Windows NT 5.0 Active Directory defines an administrative hierarchy wherein policies and class stores associated therewith are centrally supported, such that applications and components may be centrally assigned and provided to policy recipients including individual users, individual computers, or a group of users (e.g., in an Organizational Unit). Class stores may be configured to contain packages of component and application information according to functional areas, level of security access, or other criteria as determined by an administrator. Component categories (e.g., spreadsheet, word processor, and so on) may also be maintained, whereby a suitable application may be located by its function. For customized administration and programmatic query/installation for specific components and packages, the class store also includes a manager object that offers a set of interfaces and APIs.

Other advantages will become apparent from the following detailed description when taken in conjunction with the drawings, in which:

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram representing a computer system into which the present invention may be incorporated;

FIG. 2 is a block diagram generally illustrating hierarchical relationships between sites, domains organizational units and group policy objects of an exemplary network;

FIG. 3 is a block diagram representing how various containers including a class store container are hierarchically organized under a policy object in accordance with one aspect of the present invention;

FIG. 4 is a block diagram representing various components utilizing the class store schema to implement application deployment policy in accordance with one aspect of the present invention;

FIGS. 5A-5B comprise a flow diagram generally representing the steps taken upon user logon to implement application deployment policy according to state information maintained for applications in a class store in accordance with one aspect of the present invention; and

FIGS. 6 and 7 are flow diagrams generally representing the steps taken when attempting to locate an application and a software implementation, respectively, using the class store as needed in accordance with one aspect of the present invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

Exemplary Operating Environment

FIG. 1 and the following discussion are intended to provide a brief general description of a suitable computing environment in which the invention may be implemented. Although not required, the invention will be described in the general context of computer-executable instructions, such as program modules, being executed by a personal computer. Generally, program modules include routines, programs, objects, components, data structures and the like that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the invention may be practiced with other computer system configurations, including hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers and the like. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote memory storage devices.

With reference to FIG. 1, an exemplary system for implementing the invention includes a general purpose computing device in the form of a conventional personal computer 20 or the like, including a processing unit 21, a system memory 22, and a system bus 23 that couples various system components including the system memory to the processing unit 21. The system bus 23 may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. The system memory includes read-only memory (ROM) 24 and random access memory (RAM) 25. A basic input/output system 26 (BIOS), containing the basic routines that help to transfer information between elements within the personal computer 20, such as during start-up, is stored in ROM 24. The personal computer 20 may further include a hard disk drive 27 for reading from and writing to a hard disk, not shown, a magnetic disk drive 28 for reading from or writing to a removable magnetic disk 29, and an optical disk drive 30 for reading from or writing to a removable optical disk 31 such as a CD-ROM or other optical media. The hard disk drive 27, magnetic disk drive 28, and optical disk drive 30 are connected to the system bus 23 by a hard disk drive interface 32, a magnetic disk drive interface 33, and an optical drive interface 34, respectively. The drives and their associated computer-readable media provide non-volatile storage of computer readable instructions, data structures, program modules and other data for the personal computer 20. Although the exemplary environment described herein employs a hard disk, a removable magnetic disk 29 and a removable optical disk 31, it should be appreciated by those skilled in the art that other types of computer readable media which can store data that is accessible by a computer, such as magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, random access memories (RAMs), read-only memories (ROMs) and the like may also be used in the exemplary operating environment.

A number of program modules may be stored on the hard disk, magnetic disk 29, optical disk 31, ROM 24 or RAM 25, including an operating system 35 (preferably Windows NT), one or more application programs 36, other program modules 37 and program data 38. A user may enter commands and information into the personal computer 20 through input devices such as a keyboard 40 and pointing device 42. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner or the like. These and other input devices are often connected to the processing unit 21 through a serial port interface 46 that is coupled to the system bus, but may be connected by other interfaces, such as a parallel port, game port or universal serial bus (USB). A monitor 47 or other type of display device is also connected to the system bus 23 via an interface, such as a video adapter 48. In addition to the monitor 47, personal computers typically include other peripheral output devices (not shown), such as speakers and printers.

The personal computer 20 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 49. The remote computer 49 may be another personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the personal computer 20, although only a memory storage device 50 has been illustrated in FIG. 1. The logical connections depicted in FIG. 1 include a local area network (LAN) 51 and a wide area network (WAN) 52. Such networking environments are commonplace in offices, enterprise-wide computer networks, Intranets and the Internet.

When used in a LAN networking environment, the personal computer 20 is connected to the local network 51 through a network interface or adapter 53. When used in a WAN networking environment, the personal computer 20 typically includes a modem 54 or other means for establishing communications over the wide area network 52, such as the Internet. The modem 54, which may be internal or external, is connected to the system bus 23 via the serial port interface 46. In a networked environment, program modules depicted relative to the personal computer 20, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.

For purposes of the following description, in accordance with aspects of the present invention, a user subject to policy including application deployment policy may be logging onto the computer system 20, while the class store schema is maintained in one or more of the remote computers 49. Notwithstanding, it can be readily appreciated that the class store may physically reside on the client (user) machine.

CLASS STORE SCHEMA

The present invention is described herein with reference to the Microsoft.RTM. Windows NT.RTM. operating system, and in particular to the flexible hierarchical structure of sites, domains and/or organizational units of a Windows NT.RTM. Active Directory 58. Notwithstanding, there is no intention to limit the present invention to Windows NT.RTM. or the Active Directory, but on the contrary, the present invention is intended to operate with and provide benefits with any operating system, architecture and/or mechanisms that utilize network information.

Users and machines in a domain (collectively policy recipients) have associated user and machine objects 60, 62 (FIG. 2). As shown in FIG. 2, based on a hierarchy of the domain 64 and organizational units (e.g., 66.sub.a -66.sub.d,66.sub.y -66.sub.z, into which the objects are placed, a policy recipient may have one or more policies (in group policy objects or GPOs) 68.sub.A -68D, 68.sub.Y -68.sub.Z associated therewith. U.S. patent application Ser. No. 09/134,805 assigned to the assignee of the present invention and hereby incorporated by reference herein in its entirety, describes how the policy within an organization is managed using group policy. In general, group policy is an umbrella under which manageable policies are maintained. Any directory container, e.g., site, domain or organizational unit, may be set up by an administrator to be centrally managed using group policy by specifying a group policy that contains the management policy for the organizational unit or domain. For example, a single group policy may contain the policy settings for one or more organizational units or domains, whereby the organizational units and domains that have the same group policy essentially have the same policy enforcement.

A significant policy consideration that may be implemented under a group policy is the management of applications. In accordance with one aspect of the present invention and as shown in FIG. 3, if application management is set up for a group policy, (e.g., object 68.sub.B), a class store 70 is created under the group policy 66.sub.B, essentially to store the state of deployment of managed applications. More particularly, the first time the policy administrator attempts to deploy an application under the group policy, a class store is created, and thus the existence of a class store in a group policy indicates that application management is in effect for this group policy. In a preferred embodiment, the class store 70 uses the Windows NT.RTM. Active Directory 58 (FIG. 4) as its centralized store and ties into the administrative hierarchy defined thereby, i.e., the class store 70 is a container object (objectclass=ClassStore) in the Active Directory 58. The class store schema is LDAP3.0 based, a standard protocol for Directory access.

The Class Store is the component that provides the framework for deploying application resources in the Active Directory 58 and making the deployment policy available to policy recipients (i.e., users and machines). In other words, the class store container is the administration unit for applications deployment. Access and administration privileges are controlled by standard access control properties on the class store container object 70.

Each policy such as 68.sub.B thus may have at least one class store 70 associated therewith to enable the central deployment and management of applications, components and services across a network. As described in detail below, via the policy 68.sub.B and the associated class store 70, applications and components may be assigned to a policy recipient comprising a group of users, individual users, or to individual computers of a directory container such as the organizational unit 66.sub.B. Note that a user or computer can have multiple class stores associated therewith. For example, a user under organizational unit 66.sub.B has the class store 70 of the policy 66.sub.A associated therewith, along with any class store or stores of the policy 68.sub.A associated with the domain 64. The applications catalogued in a class store define the application policy for the organizational unit or domain associated with the policy, i.e., the class store hosts application deployment. In this manner, applications and/or components in a class store are available as needed, while updates to components and/or applications may be performed once in a centralized location. For example, in accordance with a policy set by an administrator, users may automatically obtain new versions of applications and components as they become available.

FIG. 3 shows various containers under a class store 70, including an application package container 72, object class container 74 and component categories container 76. Packages are stored and cataloged under the class store 70, and may be available from various vendors for different platforms, activation modes, access control, setup, and installation information. A package may include an entire application (e.g., Microsoft.RTM. Word or Excel), a set of binary component implementations packaged together, or a standalone COM component (e.g., an ActiveX.TM. control).

The Class Store object 70 is the top-level container of a Class Store hierarchy. Its Directory object class is Class Store, and as shown in FIG. 3, includes the container objects, CN=Packages, CN=Classes and CN=Categories. The class store object information is set forth in TABLE 1 below: (Key Fields--None)

    TABLE 1
    Common-Name     Class-Store
    Admin-Display-  Class-Store
    Name
    Admin-          Class-Store
    Description
    Object-Class    Class-Schema
    Comment         Class store container
    LDAP-Display-   ClassStore
    Name
    Governs-ID      1.2.840.113556.1.5.44
    Class Type      Structural Class
    Rdn-Att-Id      Common-Name
    Schema-ID-GUID  {bf967a84-0de6-11d0-a285-00aa003049e2}
    Default UI      Hidden
    State
    System-Only     FALSE
    Default-        D: (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA) (A;;RPWPCR
    Security-       CCDCLCLORCWOWDSDDTSW;;;SY) (A;;RPLCLORC;;;AU)S: (A
    Descriptor      U;SAFA;WDWOSDDTWPCRCCDCSW;;;WD)
    Subclass of     Top
    Poss-Superiors  Container;Domain-DNS;Organizational-Unit;Class-
                    Store;User;Group;Computer;Domain-Policy
    MAY contain     App-Schema-Version
                    Last-Update-Sequence
                    Next-Level-Store
                    Version-Number

    TABLE 2
    Common-Name     Package-Registration
    Admin-Display-  Package-Registration
    Name
    Admin-          Package-Registration
    Description
    Object-Class    Class-Schema
    Comment         Class store: registration information for an
                    application
    LDAP-Display-   Package Registration
    Name
    Governs-ID      1.2.840.113556.1.5.49
    Class Type      Structural Class
    Rdn-Att-Id      Common-Name
    Schema-ID-GUID  {bf967aa6-0de6-11d0-a285-00aa003049e2}
    Default UI      Hidden
    State
    System-Only     FALSE
    Default-        D:
    Security-       (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)
    Descriptor      (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)
                    (A;;RPLCLORC;;;AU) S:
                    (A U;SAFA;WDWOSDDTWPCRCCDCSW;;;WD)
    Subclass of     Top
    Poss-Superiors  Class-Store
    MAY contain     Can-Upgrade-Script
                    Categories
                    COM-ClassID
                    COM-InterfaceID
                    COM-ProgID
                    COM-Typelib-Id
                    COM-Unique-Package-ID
                    Execution-Context
                    File-Ext-Priority
                    File-Extension
                    Icon-Path
                    Install-Ui-Level
                    Last-Update-Sequence
                    Locale-ID
                    Machine-Architecture
                    Managed-By
                    Msi-File-List
                    Msi-Script
                    Msi-Script-Name
                    Msi-Script-Path
                    Msi-Script-Size
                    OS-Version
                    Package-Flags
                    Package-Name
                    Package-Type
                    Product-Code
                    Setup-Command
                    Upgrade-Product-Code
                    Vendor
                    Version-Number-Hi
                    Version-Number-Lo

    TABLE 3
    Common-Name     Class-Registration
    Admin-Display-  Class-Registration
    Name
    Admin-          Class-Registration
    Description
    Object-Class    Class-Schema
    Comment         Class Store: Registration information for a COM
                    Object
    LDAP-Display-   ClassRegistration
    Name
    Governs-ID      1.2.840.113556.1.5.10
    Class Type      Structural Class
    Rdn-Att-Id      Common-Name
    Schema-ID-GUID  {bf967a82-0de6-11d0-a285-00aa003049e2}
    Default UI      Hidden
    State
    System-Only     FALSE
    Default-        D:
    Security-       (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)
    Descriptor      (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)
                    (A;;RPLCLORC;;;AU)
                    S: (AU;SAFA;WDWOSDDTWPCRCCDCSW;;;WD)
    Subclass of     Leaf
    Poss-Superiors  Class-Store
    MAY contain     COM-CLSID
                    COM-InterfaceID
                    COM-Other-Prog-Id
                    COM-ProgID
                    COM-Treat-As-Class-Id
                    File-Extension
                    Implemented-Categories
                    Managed-By
                    MIME-Types
                    Required-Categories

    TABLE 4
    Common-Name     Category-Registration
    Admin-Display-  Category-Registration
    Name
    Admin-          Category-Registration
    Description
    Object-Class    Class-Schema
    Comment         Class store: registration information for a
                    component category
    LDAP-Display-   CategoryRegistration
    Name
    Governs-ID      1.2.840.113556.1.5.74
    Class Type      Structural Class
    Rdn-Att-Id      Common-Name
    Schema-ID-GUID  {7d6c0e9d-7e20-11d0-afd6-00c04fd930c9}
    Default UI      Hidden
    State
    System-only     FALSE
    Default-        D:
    Security-       (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)
    Descriptor      (A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)
                    (A;;RPLCLORC;;;AU)
                    S: (AU;SAFA;WDWOSDDTWPCRCCDCSW;;;WD)
    Subclass of     Leaf
    Poss-Superiors  Class-Store
    MAY contain     Category-Id
                    Locale-ID
                    Localized-Description
                    Managed-By

                      TABLE 5
                      Assigned
                      Published with AutoInstall
                      Published with no AutoInstall
                      Minor Revision (Patch)
                      Upgraded with uninstall
                      Upgraded without Uninstall
                      Uninstall
                      Orphan
                      Pilot Deployment

    TABLE 6
    ACTFLG_Published         Application is in Published State.
    ACTFLG_Assigned          Application is in Assigned State;
                             Will be mandatory, made available.
    ACTFLG_UserInstall       May be installed by desktop user
                             using Add/Remove Programs applet.
    ACTFLG_OnDemandInstall   May be automatically installed
                             during activation by Shell/OLE/VB
                             based on a File Extension, CLSID
                             or ProgId.
    ACTFLG_Orphan            This application is Orphaned. It
                             is no longer deployed, and all
                             existing installs may be left as
                             is.
    ACTFLG_Uninstall         This application is to be
                             Uninstalled on all desktops where
                             it was installed as a result of
                             this deployment.
    ACTFLG_Pilot             This application is available as a
                             Pilot Only. As such it is not
                             deployed, but may be installed
                             using Add/Remove Programs.

    TABLE 7
    ACTFLG_OrphanOnPolicyRemoval        Orphan the application
                                        when Policy is removed.
    ACTFLG_UninstallOnPolicyRemoval     Uninstall the
                                        application when Policy
                                        is removed.

                            CsEnumApps
    STDAPI CsEnumApps      (LPOLESTR       pszPackageName,
                           GUID            *pCategory,
                           ULONGLONG       *pLastUsn,
                           DWORD           dwAppFlags,
                           IEnumPackage    **ppIEnumPackage);

                           CsGetAppInfo
    STDAPI CsGetAppInfo  (uCLSSPEC          *   pclsspec,
                         QUERYCONTEXT       *   pQueryContext,
                         PACKAGEDISPINFO    *   pPackageInfo);

        STDAPI ReleasePackageInfo
            (PACKAGEDISPINFO *pPackageInfo);
        STDAPI ReleasePackageDetail
            (PACKAGEDETAIL *pPackageDetail);
        STDAPI ReleaseAppCategoryInfoList
            (APPCATEGORYINFOLIST *pAppCategoryInfoList);

                      Interface IClassAccess
                     IClassAccess::GetAppInfo
    HRESULT  GetAppInfo(
        [in] UCLSSPEC  *pClassSpec,
        [in] QUERYCONTEXT  *pQryContext,
        [out] PACKAGEDISPINFO  *pInstallInfo
    typedef union switch (DWORD tyspec)
        {
        case TYSPEC_CLSID:
          CLSID  clsid;
        case TYSPEC_IID:
          IID  iid;
        case TYSPEC_TYPELIB:
          GUID  typelibID;
        case TYSPEC_FILEEXT:
          LPOLESTR pFileExt;
        case TYSPEC_MIMETYPE:
          LPOLESTR pMimeType;
        case TYSPEC_PROGID:
          LPOLESTR pProgId;
        case TYSPEC_FILENAME:
          LPOLESTR pFileName;
        case TYSPEC--JAVACLASS:
          LPOLESTR pJavaClassName;
        case TYSPEC_PACKAGENAME:
          struct {
           LPOLESTR pPackageName;
           GUID  GpoId;
          } ByName;
        case TYSPEC_SCRIPTNAME:
          struct {
           LPOLESTR pScriptName;
           GUID  GpoId;
          } ByScript;
        } uCLSSPEC;

                    IClassAccess::EnumPackages
    HRESULT EnumPackages (
        [in, unique]      LPOLESTR          pszPackageName,
        [in, unique]      GUID              *pCategory,
        [in, unique]      ULONGLONG         *pLastUsn,
        [in]              DWORD             dwAppFlags,
        [out]             IEnumPackage      **ppIEnumPackage
        );

                      Interface IClassAdmin
                      IClassAdmin:AddPackage
    HRESULT AddPackage(
        [in]        LPOLESTR                 pszPackageName,
        [in]        PACKAGEDETAIL            *pPackageDetail
        );
                    IClassAdmin::RemovePackage
    HRESULT RemovePackage(
        [in]        LPOLESTR                 pszPackageName,
        [in]        DWORD                    dwFlags
        );
               IClassAdmin::ChangePackageProperties
    HRESULT ChangePackageProperties(
        [in]        LPOLESTR                 pszPackageName,
        [in, unique] LPOLESTR                 pszNewName,
        [in, unique] DWORD                    *pdwFlags,
        [in, unique] LPOLESTR                 pszUrl,
        [in, unique] LPOLESTR                 pszScriptPath,
        [in, unique] UINT                     *pInstallUiLevel,
        [in, unique] DWORD                    *pdwRevision
        );
               IClassAdmin::ChangePackageCategories
    HRESULT ChangePackageCategories(
        [in]        LPOLESTR                 pszPackageName,
        [in]        UINT                     cCategories,
        [in, size_  GUID                     *rpCategory
        is(c-
        Categories)]
        );
                IClassAdmin::SetPriorityByFileExt
    HRESULT SetPriorityByFileExt(
        [in]        LPOLESTR                 pszPackageName,
        [in]        LPOLESTR                 pszFileExt,
        [in]        UINT                     Priority
        );
                    IClassAdmin::EnumPackages
    HRESULT EnumPackages(
        [in, unique] LPOLESTR                 pszFileExt,
        [in, unique] GUID                     *pCategory,
        [in]        DWORD                    dwAppFlags,
        [in, unique] DWORD                    *pdwLocale;
        [in, unique] CSPLATFORM               *pPlatform,
        [out]       IEnumPackage             **ppIEnumPackage
        );
                  IClassAdmin::GetPackageDetails
    HRESULT GetPackageDetails(
        [in]        LPOLESTR                 pszPackageName,
        [out]       PACKAGEDETAIL            *pPackageDetail
        );
                  IClassAdmin::GetAppCategories
    typedef struct tagAPPCATEGORYINFO
    {
        LCID        Locale;
        LPOLESTR    pszDescription;
        GUID        AppCategoryId;
    } APPCATEGORYINFO;
    typedef struct tagAPPCATEGORYINFOLIST
    {
        DWORD       cCategory;
        [size.sub.--  APPCATEGORYINFO          *pCategoryInfo;
        is(c-
        Category),
        unique]
    } APPCATEGORYINFOLIST;
    HRESULT GetAppCategories(
        [in]        LCID                     Locale,
        [out]       APPCATEGORYINFOLIST      *pAppCategoryList
        );
                 IClassAdmin::RegisterAppCategory
    HRESULT RegisterAppCategory(
        [in]        APPCATEGORYINFO          *pAppCategory
        );
                IClassAdmin::UnregisterAppCategory
    HRESULT UnregisterAppCategory(
        [in]        GUID                     *pAppCategoryId
        );
                       IClassAdmin::Cleanup
    HRESULT Cleanup(
        [in]        FILETIME                 *pTimeBefore
        );
                      Interface IEnumPackage
    typedef struct tagPACKAGEDISPINFO
    {
        LPOLESTR           pszPackageName;
        DWORD              dwActFlags;
        CLASSPATHTYPE      PathType
        LPOLESTR           pszScriptPath;
        LPOLESTR           pszPublisher;
        LPOLESTR           pszUrl;
        UINT               InstallUiLevel;
        ULONG              cScriptLen;
        ULONGLONG          Usn;
        DWORD              dwVersionHi;
        DWORD              dwVersionLo;
        DWORD              dwRevision;
        GUID               ProductCode;
        GUID               *pClsid;
        GUID               GpoId;
        LPOLESTR           pszPolicyName;
        UINT               cUpgrades;
        [size_is(cUpgrades)] LPOLESTR               *prgUpgrade-
                                                  Script;
        [size_is(cUpgrades)] DWORD                  *prgUpgrade-
                                                  Flag;
    } PACKAGEDISPINFO;
    interface IEnumPackage : IUnknown
    {
        HRESULT Next(
            [in]               ULONG celt,
            [out, size_is(celt), length_is(*pceltFetched)]
            PACKAGEDISPINFO *rgelt,
            [out]              ULONG *pceltFetched
            );
        HRESULT Skip(
            [in]               ULONG celt);
        HRESULT Reset();
        HRESULT Clone(
            [out]              IEnumPackage **ppenum);
    }

    TABLE 8
    PszPackageName: Deployment name of Package.
    DwActFlags: Deployment state.
    PathType: Package Type.
    PszScriptPath: Script Path for Package
    CscriptLen: Size of the Script for the Package
    PszPublisher: Name of Package Publisher.
    PszUrl: URL where more info is available.
    InstallUiLevel: UI Level for installation.
    Usn: Deployment name of Package
    DwVersionHi: Package Major Version Number
    DwVersionLo: Package Minor Version Number
    DwRevision: Package Revision Number
    ProductCode: MSI Product Code
    Pclsid: If a COM component, one CLSID the package implements.
    GpoId: Policy GUID of the group policy package is deployed
    PszPolicyName: Policy Name of the group policy package is
    Deployed
    Cupgrades: Number of Upgrade relationships
    PrgUpgradeScript: Script that has upgrade relationship
    PrgUpgradeFlag: Type of upgrade relationship
      .cndot. Upgrade
      .cndot. Upgrades w/Uninstall
      .cndot. UpgradedBy

• Inventors
  Mishra, Debi P.; Horstmann, Markus; Shaji, Ullattil;
• Assignee
  Microsoft Corporation (Redmond, WA)
• Published
  May-14-2002
• Current US Classes:
  707/10
  707/103R
  707/104.1
  707/9
  709/203
  709/219
  709/242
  709/244
  717/170
• Application #
  158023
• International Classes
  G06F 009/445; G06F 017/30
• Field of Search
  717/11 713/100 713/155 713/156 713/162 713/182 713/201 713/200 709/203 709/217 709/221-223 709/242 709/244 709/239 709/219 707/10 707/104 707/203 707/204 707/9 707/103
• Examiner
  Dam; Tuan Q.
• Agent
  Michalik & Wylie, PLLC
• US Patent References:
  5421009
  5473772
  5535326
  5555416
  5586304
  5625823
  5630076
  5644766
  5655081
  5659547
  5692129
  5732266
  5732275
  5742829
  5752042
  5764992
  5768566
  5778234
  5784612
  5790664
  5790856
  5796967
  5805897
  5835911
  5859969
  5859978
  5867713
  5867714
  5870762
  5897640
  5925127
  5930513
  5930514
  5933647
  5954827
  5960204
  5966540
  5978590
  5987504
  5999740
  6006034
  6006035
  6009274
  6009401
  6021438
  6023586
  6029147
  6041333
  6067582
  6131192
  6151643
  6151708
  6161218
  6205527