Operating system application programming interfaces and methods of using operating systems

• US 20030177285A1
• Filed: 03/10/2003
• Published: 09/18/2003
• Est. Priority Date: 06/16/1999
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Galen C. Hunt, Gerald Cermak, Robert J. Stets Jr
• Inventors: Hunt, Galen C., Cermak, Gerald, Stets, Robert J. Jr.
• Granted Patent: US 7,334,235 B2
• Time in Patent Office: Days
• US Class Current: 719/328
• CPC Class Codes: G06F 2209/463 Naming
• CPC Class Codes: G06F 9/465 Distributed object oriented systems remote method invocation [RMI] G06F9/548

Abstract

Operating system functions are defined as objects that are collections of data and methods. The objects represent operating system resources. The resource objects can be instantiated and used across process and machine boundaries. Each object has an associated handle that is stored in its private state. When an application requests a resource, it is given a second handle or pseudo handle that corresponds with the handle in the object'"'"'s private state. The second handle is valid across process and machine boundaries and all access to the object takes place through the second handle. This greatly facilitates remote computing. In preferred embodiments, the objects are COM objects and remote computing is facilitated through the use of Distributed COM (DCOM) techniques. Other embodiments of the invention provide legacy and versioning support by identifying each resource, rather than the overall operating system, with a unique identifier that can specified by an application. Different versions of the same resource have different identifiers. This ensures that applications that need a specific version of a resource can receive that version. This also ensures that an application can specifically request a particular version of a resource by using its unique identifier, and be assured of receiving that resource. Other embodiments of the invention provide legacy support by intercepting calls for operating system functions and transforming those calls into object calls that can be understood by the resource objects. This is accomplished in preferred embodiments by injecting a level of indirection between an application and an operating system.

Claims

1. A method of operating an operating system comprising:

defining a translation layer between an application and an operating system, wherein the operating system includes functions that are callable by the application;

receiving calls from the application in the translation layer;

translating the calls with the translation layer to provide translated calls; and

calling operating system functions with the translated calls.

2. The method of claim 1, wherein the defining of the translation layer comprises instantiating a plurality of programming objects representing operating system resources, wherein the programming objects include data and methods, and wherein the methods correspond to operating system functions.

3. The method of claim 1, wherein the defining of the translation layer comprises instantiating a plurality of programming COM objects representing operating system resources, wherein the programming COM objects include data and methods, and wherein the methods correspond to operating system functions, and further wherein object data is accessible through its methods.

4. The method of claim 1, wherein the receiving of the calls comprises receiving calls across at least one process boundary.

5. The method of claim 1, wherein the receiving of the calls comprises receiving calls across at least one machine boundary.

6. The method of claim 1, wherein:

the defining of the translation layer comprises instantiating a plurality of programming objects representing operating system resources, wherein the programming objects include data and methods, and wherein the methods correspond to operating system functions; and

the receiving of the calls comprises receiving calls across at least one process boundary.

7. The method of claim 1, wherein:

the defining of the translation layer comprises instantiating a plurality of programming COM objects representing operating system resources, wherein the programming COM objects include data and methods, and wherein the methods correspond to operating system functions, and further wherein object data is accessible through its methods; and

the receiving of the calls comprises receiving calls across at least one process boundary.

8. The method of claim 1, wherein:

the defining of the translation layer comprises instantiating a plurality of programming objects representing operating system resources, wherein the programming objects include data and methods, and wherein the methods correspond to operating system functions; and

the receiving of the calls comprises receiving calls across at least one machine boundary.

9. The method of claim 1, wherein:

the defining of the translation layer comprises instantiating a plurality of programming COM objects representing operating system resources, wherein the programming COM objects include data and methods, and wherein the methods correspond to operating system functions, and further wherein object data is accessible through its methods; and

the receiving of the calls comprises receiving calls across at least one machine boundary.

10. The method of claim 1, wherein the calls that are received from the application utilize a handle that is not understood by the operating system functions.

11. The method of claim 1, wherein the calls that are received from the application utilize a first handle that is not understood by the operating system functions, and wherein the translating of the calls comprising finding a second handle that corresponds to the first handle and that is understood by the operating system functions.

12. A method of organizing operating system resources comprising:

representing a plurality of operating system resources as programming objects, each programming object representing an operating system resource and having one or more interfaces that define methods that can be used by applications to access and manipulate the resource;

assigning each interface a unique identifier, wherein different versions of a resource are associated with different unique identifiers that can be used by applications to access particular versions of a resource; and

specifying a unique identifier any time an application wants to use a particular resource.

13. The method of claim 12, wherein the unique identifier comprises a globally unique identifier (GUID).

14. The method of claim 12, wherein the unique identifiers represent the syntax of a particular programming object.

15. The method of claim 12, wherein the unique identifiers represent the semantics of a particular programming object.

16. The method of claim 12, wherein the unique identifiers represent the syntax and the semantics of a particular programming object.

17. The method of claim 12, wherein the unique identifiers comprise hexadecimal numbers.

18. The method of claim 12, wherein the specifying of the unique identifier comprises specifying at least one unique identifier across a process boundary.

19. The method of claim 12, wherein the specifying of the unique identifier comprises specifying at least one unique identifier across a machine boundary.

20. The method of claim 12, wherein the specifying of the unique identifier comprises specifying at least one unique identifier across one of a process or machine boundary.

21. The method of claim 12, wherein the specifying of the unique identifier comprises specifying a plurality of unique identifiers, at least some of which being specified across a process boundary, and others of which being specified across a machine boundary.

22. The method of claim 12 further comprising:

determining, based on the unique identifier, whether the operating system has the resource that corresponds to the unique identifier; and

if the operating system does not have the resource that corresponds to the unique identifier, retrieving the resource that corresponds to the unique identifier from a location that can be ascertained by the operating system.

23. The method of claim 22, wherein the location is across at least one machine boundary.

24. The method of claim 22, wherein the location comprises a web site that provides access to code that can be downloaded by the operating system for providing the resource to the application.

25. A computer program embodied on a computer-readable medium that contains instructions which, when executed by a computer, perform the steps comprising:

creating a first handle that is associated with an operating system resource that is represented as a programming object having data and one or more methods;

creating a second handle that corresponds with the first handle;

storing the first handle in the programming object'"'"'s private state;

passing the second handle to an application instead of the first handle when an application makes calls to create the operating system resource; and

using the second handle to access the operating system resource.

26. The steps of claim 25, wherein the first handle is only valid within its own process, and the second handle is valid outside of the process.

27. The steps of claim 25, wherein the second handle is valid across to process and machine boundaries.

28. The steps of claim 25, wherein the first handle is only valid within its own process, and the second handle is valid across process and machine boundaries.

29. The steps of claim 25, wherein the second handle comprises an interface pointer to an interface of the programming object.

30. The method of claim 25 further comprising determining whether the object is in process, local, or remote before using the second handle to access it.

31. One or more programmed computers having code that contains instructions which, when executed by a computer performs the following steps:

calling an operating system function with a call having a syntax, wherein the call is configured to create or use an operating system resource;

intercepting the call;

changing the syntax of the call to provide a second call with a changed syntax; and

calling a programming object with the second call, wherein the programming object has data and methods and represents the operating system resource.

32. The steps of claim 31 wherein the intercepting comprises interposing a detour function between an application and the operating system, wherein the detour function intercepts every application call to the operating system.

33. The steps of claim 32, wherein the calling of the operating system function comprises doing so across at least one process boundary.

34. The steps of claim 32, wherein the calling of the operating system function comprises doing so across at least one machine boundary.

35. The steps of claim 32, wherein the detour function is configured to enable communication of the call having the appropriate syntax across at least one of a process boundary or machine boundary using DCOM communication techniques.

36. The steps of claim 32 further comprising calling a trampoline that contains code that enables the detour function to remain within its own process.

37. A method of building an application comprising:

establishing a library containing one or more interfaces that are identified by a unique identifier, wherein the interfaces comprise one or more methods that can be used to manipulate programming objects that represent operating system resources; and

linking an application against the unique identifiers.

38. The method of claim 37, wherein the linking of the application takes place against the unique identifiers instead of any dynamic link libraries (DLLs).

39. The method of claim 37, wherein the unique identifier comprises a globally unique identifier (GUID).

40. The method of claim 37, wherein the unique identifier represents the syntax of the interface that it identifies.

41. The method of claim 37, wherein the unique identifier represents the semantics of the interface that it identifies.

42. The method of claim 37, wherein the unique identifier represents the syntax and the semantics of the interface that it identifies.

43. A computer readable medium having computer-readable instructions thereon, which when executed by a computer perform the following steps:

representing a plurality of operating system resources as objects having one or more interfaces through which one or more resources can be accessed;

assigning each interface a globally unique identifier (GUID) that can be used by an application to access a particular resource, wherein the GUIDs are assigned so that they distinguish between different versions of the same object and represent the syntax and semantics of an object; and

specifying the unique identifier across at least one process or machine boundary any time an application wants to use a particular object.

44. The steps of claim 43 further comprising determining, based on the unique identifier, whether the operating system has the object that corresponds to the unique identifier and if not, ascertaining the location of the object and retrieving the object from the location.

45. One or more computer-readable media comprising:

a library of operating system functions;

a plurality of programming objects representing respective operating system resources, each programming object comprising data and associated methods, wherein the data is accessible only through the methods;

wherein the methods of the programming objects are callable to access the resources represented by the objects; and

wherein the methods of the programming objects are responsive to call the functions of the function library.

46. The computer readable media of claim 45 further comprising a plurality of pairs of first and second handles, wherein the handle pairs correspond to one another, and wherein the first handles of each pair are usable by one or more applications to call the programming objects, and wherein the second handles of each pair are usable by the objects to call the functions of the function library.

47. The computer readable media of claim 45, wherein the programming objects are distributed across one or more process or machine boundaries.

48. The computer readable media of claim 45, wherein the media comprise a computer network comprising a plurality of computers connected for data communication.

49. A method of utilizing an existing function library of an operating system comprising:

defining a plurality of programming objects representing respective operating system resources, each programming object comprising data and associated methods, wherein the data is accessible only through the methods;

calling the methods of the programming objects to access the resources represented by the objects; and

calling the functions of the function library from the programming object methods.

50. The method of claim 49, wherein said calling steps are performed using two different handles that are associated with one another.

51. The method of claim 49, wherein the calling of the methods comprises first calling a detour using a first call syntax, using the detour to change the first call syntax into a second call syntax that is different from the first call syntax, and second calling the methods using the second call syntax.

52. The method of claim 49, wherein the calling of the methods comprises doing so across process and machine boundaries.

53. The method of claim 49, wherein the calling of the methods comprises first calling a detour from an application and second calling a trampoline from the detour, wherein the detour contains code that enables programming objects within a current process to be called, and wherein the trampoline is callable by the detour and contains code to enable the detour to stay within its own process.

54. A method of utilizing an object-oriented operating system function library from a legacy application program that is configured to utilize non-object-oriented functions of an operating system function library, comprising:

defining a plurality of detour functions corresponding to the functions of the operating system function library;

calling a detour function from a legacy application;

calling a programming object from the detour function, wherein the programming object has data and methods; and

calling a function in the function library using one of the methods of the programming object.

55. The method of claim 54, wherein the calling of the detour function comprises using a first handle that corresponds to an operating system resource, and wherein the calling of the function comprises using a second handle that corresponds to and is different from the first handle.

56. A computer-readable medium comprising:

a plurality of programming objects that represent operating system resources, wherein the objects contain data and methods, and wherein the data is accessible through the methods;

wherein the programming objects are configured to receive calls that call the methods; and

wherein at least some of the methods are configured to call functions of an operating system to manipulate operating system resources.

57. The computer readable media of claim 56 further comprising a detour that is configured to receive a call from an application that is intended for an operating system function, and responsive thereto call a method on one of the programming objects.