Object-oriented remote procedure call networking system

Claims

Having thus described our invention, what we claim as new, and desire to secure by letters patents is:

1. A system for implementing remote procedure call services over a computer network having a plurality of alternate communication links, each of the plurality of alternate communication links having a different network protocol, the system comprising:

(a) a client node having a source network address:

(b) a server node having a task application program executing therein to provide services;

(c) a memory in the client node with a system address space and a process address space having an application program executing therein for generating a service request;

(d) a first dynamically-configurable protocol stack in the system address space configurable for connecting the client node to one of the plurality of alternate communication links by packaging data according to the network protocol of the one communication link:

(e) means responsive to the service request for providing a service object to the application program, the service object containing information for configuring the first dynamically-configurable protocol stack and destination network address of the task application program;

(f) means responsive to the service request for instantiating an API object in the client node, which API object establishes a stream extending from the application program in the process address space to the first dynamically-configurable protocol stack in system address space and inserts the service object into the data stream to configure the first dynamically-configurable protocol stack;

(g) means responsive to the configuration of the dynamically-configurable protocol stack for instantiating a first RPC object in the client node which creates a service request packet containing the service request, the source network address and the destination network address;

(h) a second dynamically-configurable protocol stack in the server node configured to connect the server node to the one alternate communication link by unpackaging data according to the network protocol of the one communication link: and

(i) interface means in the server node for receiving the service request packet and providing the service request packet to the task application program.

2. A system as recited in claim 1 further comprising:

(j) a transport object instantiated in the process address space of the memory by the application program, the transport object selecting a transport mechanism to forward the service object from the application program to the first dynamically-configurable protocol stack; and

(k) a protocol translator object instantiated in the system address space, the protocol translator object for extracting the service object from the data stream and for configuring the first dynamically-configurable protocol stack to connect the application program to the one communication link.

3. A system as recited in claim 1 wherein the interface means comprises a second API object in the server node for establishing a data path from the second dynamically-configurable protocol stack to the task application program.

4. A system as recited in claim 3 wherein the interface means comprises a second RPC object in the server node for receiving the service request packet and processing the service request.

5. A system as recited in claim 3, wherein the second API object creates a data stream object for establishing synchronous transactions between the task application program and a session layer of the second dynamically-configurable protocol stack.

6. A system as recited in claim 5, wherein the second dynamically-configurable protocol stack includes a plurality of upper protocol layer objects that are unique to the task application program executing in the server node and a plurality of lower protocol layer objects that are shared among other task application programs executing in the server node.

7. A system as recited in claim 1, wherein the first RPC object comprises:

a caller object which creates the service request packet by combining data and functions associated with the service request with the source network address and the destination network address: and wherein the second RPC object comprises:

a dispatcher object for locating subroutines in the task application program invoked by the caller object so as to perform the functions.

8. A system as recited in claim 3, wherein the first dynamically-configurable protocol stack comprises vertically-linked protocol layer objects dynamically-configurable protocol stack residing in the system address space of the memory in the client node.

9. A system as recited in claim 8, wherein one of the protocol layer objects is a network layer object of the first dynamically-configurable protocol stack, the network layer object containing state information relative to a predetermined instantiation of the first dynamically-configurable protocol stack.

10. A system as recited in claim 9, wherein the state information includes a network service access point address of the first dynamically-configurable protocol stack.

11. A system as recited in claim 10, wherein the first dynamically configurable protocol stack includes a data link layer object for formatting the service request packet, the data link object operating in connection with an interrupt service routine to move the service request packet to and from the one communication link.

12. A system as recited in claim 11, wherein the first dynamically-configurable protocol stack includes a capsulator layer object for encapsulating the service request packet, the capsulator layer having header information relating to the data link object, the header information comprising a data link service access point address of the first dynamically-configurable protocol stack and a destination address of the service request packet.

13. A system as recited in claim 12, wherein the first dynamically-configurable protocol stack includes a family layer object which contains muting information used to dispatch to the data link layer object, the routing information including the capsulator layer object.

14. A client node for use in a client-server system having a network with a plurality of alternate communication links, each of the plurality of alternate communication links using a different network protocol and a server node coupled to the network containing a task application program, the client node having a source network address and comprising:

(a) a memory with a system address space and a process address space having a client application program executing in the process address space for generating a service request;

(b) a dynamically-configurable protocol stack in the system address space configurable for connecting the client node to one of the plurality of alternate communication links by packaging data according to the network protocol of the one communication link;

(c) means responsive to the service request for providing a service object to the application program, the service object containing information for configuring the dynamically-configurable protocol stack and destination network address of the task application program;

(d) means responsive to the service request for instantiating an API object in the client node, which API object establishes a data stream extending from the application program in the process address space to the dynamically-configurable protocol stack in system address space and inserts the service object into the data stream to configure the dynamically-configurable protocol stack;

(e) means responsive to the configuration of the dynamically-configurable protocol stack for instantiating an RPC object in the client node which creates a service request packet containing the service request, the source network address and the destination network address; and

(f) means for placing the service request packet on the data stream

15. The client node as recited in claim 14, wherein the dynamically-configurable protocol stack includes a plurality of upper protocol layer objects that are unique to the client application program executing in the client node and a plurality of lower protocol layer objects that are shared among other client application programs executing in the client node.

16. A client node as recited in claim 14 further comprising:

(g) a transport object instantiated in the process address space of the memory by the application program, the transport object selecting a transport mechanism to forward the service object from the application program to the dynamically-configurable protocol stack; and

(h) a protocol translator object instantiated in the system address space, the protocol translator object for extracting the service object from the data stream and for configuring the dynamically-configurable protocol stack to connect the application program to the one communication link.

17. The client node as recited in claim 15, wherein at least one of the plurality of upper protocol layers of the dynamically-configurable protocol stack is an application layer object for exchanging service request packet with the client application program.

18. The client node as recited in claim 17, wherein at least one of the upper protocol layers of the dynamically-configurable protocol stack is a presentation layer object for presenting the service request packet in a predetermined format to the lower protocol layer objects.

19. The client node as recited in claim 18, wherein the client application layer and presentation layer objects of the dynamically-configurable protocol stack reside in the process address space of the memory.

20. The client node as recited in claim 19, wherein the RPC object comprises:

a caller object which creates the service request packet by combining data and functions associated with the service request with the source network address and the destination network address.

21. The client node as recited in claim 20, wherein the plurality of lower protocol layer objects of the dynamically configurable protocol stack and the operating system reside in a system address space of the memory.

22. The client node as recited in claim 21, further comprising a remote stream object which ensures a consistent format for the presentation of service request packet between the process address space and the system address space of the memory.

23. The client node as recited in claim 22, wherein the remote stream object comprises:

one of a request model object and a reply model object for establishing short-term synchronous transactions between the client and server nodes; and

a partial remote operation service element model object for binding the client and server nodes over long-term synchronous transactions.

24. A server node for use in a client-server system having a network with a plurality of alternate communication links, each of the plurality of alternate communication links having a different network protocol and a client node coupled to the network, the server node comprising:

(a) a memory having a system address space and it process address space having a task application program stored therein, the task application program being responsive to a service request packet from the client node for providing services to the client node;

(b) a dynamically-configurable protocol stack configured to connect the server node to the one alternate communication link by unpackaging data according to the network protocol of the one communication link;

(c) an RPC object in the server node for receiving the service request packet and processing the service request to locate and invoke the task application program;

(d) an API object in the server node for establishing a data path from the dynamically-configurable protocol stack to the RPC object; and

(e) means responsive to a creation of the task application program for instantiating a service object containing information for configuring a dynamically-configurable protocol stack in the client node and a destination network address of the task application program

25. The server node as recited in claim 24, wherein the dynamically configurable protocol stack includes a plurality of upper protocol layer objects that are unique to the task application program executing in the server node and a plurality of lower protocol layer objects that are shared among other task application programs executing in the server node.

26. The server node as recited in claim 25, wherein at least one of the plurality of upper protocol layers of the dynamically configurable protocol stack is an application layer object for exchanging the service request packet with the task application program.

27. The sewer node as recited in claim 26, wherein at least one of the upper protocol layers of the dynamically configurable protocol stack is a presentation layer object for presenting the service request packet in a predetermined format to the lower protocol layer objects of the dynamically configurable protocol stack.

28. The server node as recited in claim 27, wherein the application layer object and presentation layer object of the dynamically configurable protocol stack reside in the process address space of the memory.

29. The server node as recited in claim 28 wherein the dispatcher object and the task application program further reside in the process address space.

30. The server node as recited in claim 29, wherein the lower protocol layer objects of the dynamically configurable protocol stack and the operating system reside in the system address space of the memory.

31. The server node as recited in claim 20, further comprising a remote stream object which ensures a consistent format for the presentation of the service request packet between the process address space and the system address space of the memory.

32. The server node as recited in claim 31, wherein the remote stream object comprises one of a request model object and a reply model object for establishing short-term synchronous transactions between the server node and client node.

33. A method for configuring a data path within a node of a client-server system prior to invoking remote procedure call communication over a network having a plurality of alternate communication links, each of the alternate communication links using a different network protocol, the node including a processor and a memory, the memory having an operating system and an application program stored therein, the operating system and application program for controlling the operations of the processor, the operating system including a dynamically-configurable protocol stack, the method comprising the steps of:

(a) acquiring, in the application program, a service object from a directory service of the node, the service object including a remote service address and configuration data for one of the plurality of alternate communication links;

(b) creating a remote stream object for opening a data stream between the application program and the dynamically-configurable protocol stack;

(c) inserting the service object onto the data stream at the application program as an argument of the remote stream object;

(d) extracting the service object from the data stream at the dynamically-configurable protocol stack; and

(e) configuring the protocol stack in accordance with the configuration data in the service object to connect the application program to one of the plurality of alternate communication links using a network protocol appropriate for the one alternate communication link.

34. The method as recited in claim 33, including the step of creating a transport object for selecting a transport mechanism with which to forward the service object from the application program to the dynamically-configurable protocol stack.

35. The method as recited in claim 33, including the step of storing the remote service address in a buffer.

36. The method as recited in claim 35, including the step of returning an access point address of a newly-configured protocol stack to the application program.

37. The method as recited in claim 36, including the step of recording the access point address in the directory service.

38. A method for invoking, and responding to, a remote procedure call service request at client and sewer nodes of a computer network, the client and server nodes coupled to a communications network having a plurality of alternate communication links each of the plurality of alternate communication links using a different network protocol, each of the client and server nodes including a processor and a memory, the memory having an operating system and an application program stored therein for controlling the operations of the processor, each of the operating systems including a dynamically-configured protocol stack, the method comprising the steps of:

(a) issuing a service request at a client application of the client node, the service request including an access point address of a client dynamically-configured protocol stack;

(b) creating a caller object to invoke a remote procedure call protocol in response to the service request;

(c) creating a first remote stream object for opening a first data stream between the client application and the client dynamically-configured protocol stack;

(d) inserting the service request onto the first data stream at the client application;

(e) appending a remote address to the service request at the client dynamically-configured protocol stack and transmitting the service request over the communications network to the sewer node;

(f) opening a second data stream from a second remote stream object, the second data stream passing the service request between a server dynamically-configured protocol stack and a server application of the sewer node; and

(g) extracting the service request from the second data stream using a dispatcher object and passing the service request to the server application in accordance with the remote address for execution of the service request.

39. The method as recited in claim 38, including the step of creating a transport object at the client application for selecting a transport mechanism with which to forward the service object from tile client application to the client protocol stack.

40. The method as recited in claim 39, including the step of:

(h) receiving the service request at a protocol translator object of the client protocol stack in accordance with the access point address, the access point address functioning as a source address of the service request.

41. The method as recited in claim 40, wherein the step of appending the remote address further comprises the step of obtaining the remote address from a first buffer, the remote address functioning as a destination address of the service request.

42. The method as recited in claim 41, wherein the step of appending the remote address further comprises the step of formatting, at the client dynamically-configurable protocol stack, the service request as a first packet prior to transmitting the service request over the communications network.

43. The method as recited in claim 42, including the steps of:

(i) receiving the first packet at the server node;

(j) stripping the source address from the first packet; storing the source address in a second buffer; and

(k) reformatting the first packet as the service request at the server dynamically-configured protocol stack.

44. The method as recited in claim 43, including the step of passing the request up the server protocol stack to the destination address.

45. The method as recited in claim 44 wherein in response to the execution of the service request requiring a reply, the method further comprises the steps of:

(l) inserting the reply onto the second data stream;

(m) passing the reply down the server dynamically-configurable protocol stack;

(n) obtaining the source address from the second buffer;

(o) appending the source address to the reply as a reply destination address;

(p) formatting the reply as a second packet; and

(q) transmitting the second packet over the network to the client node.

46. The method as recited in claim 45, including the steps of:

(r) receiving the second packet at the client node;

(s) reformatting the second packet as the reply; and

(t) passing the reply up the client dynamically-configurable protocol stack to the client application in accordance with the reply destination address.

COPYRIGHT NOTIFICATION

Portions of this patent application contain materials that are subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document, or the patent disclosure, as it appears in the Patent and Trademark Office.

1. Field of the Invention

This invention relates generally to improvements in distributed computer networks and, more specifically, to operating system software for efficiently implementing client-server systems in distributed service networks.

2. Background of the Invention

Computer hardware is becoming increasingly distributed and remote, resulting in networks of computers for solving problems in concert rather than as stand-alone systems. Although such distributed "services" networks generally facilitate problem-solving, they also increase the need for flexibility and functionality in software programs operating on the computers.

An example of a distributed services computer network is a "client-server" system 100 shown in FIG. 1. The system 100 comprises a collection of client nodes 102, e.g., workstations or personal computers, that communicate over a network 104 with various server nodes 106. The servers are typically computers having hardware and software elements that provide a sophisticated set of services, or operations, for use by the client nodes 102 to increase the efficiency of their own operations.

Several types of networks, including local area networks (LANs), may be employed in the client-server system 100. ALAN is a limited area network that typically consists of a transmission medium, such as a coaxial cable or twisted pair, for interconnecting the client and server nodes. Each node is connected to the transmission medium at an address which uniquely identifies the node and which is used to route data from one node to another.

Nodes coupled to the network typically communicate by exchanging discrete "packets" of data according to predefined "protocols". In this context a protocol consists of a set of rules defining how the nodes interact with each other. For example, communication in the client-server system 100 typically takes the form of packet exchanges, wherein the clients 102 send requests to the servers 112, which perform their services and communicate results back to the clients.

In order to reduce design complexity, most networks are organized as a series of hardware and software levels or "layers" within each node. These layers interact to format data for transfer between nodes that are communicating over the network. Specifically, predetermined services are performed on the data as it passes through each layer and the layers communicate with each other by means of the predefined protocols. This layered design permits each layer to offer selected services to other layers using a standardized interface that shields those layers from the details of actual implementation of the services.

In an attempt to standardize network architectures, i.e., the sets of layers and protocols used within a network, a generalized model has been proposed by the International Standards Organization (ISO). The model, called the open systems interconnection (OSI) reference model, addresses the interconnection of systems that are "open" for communication with other systems. The proposed OSI model has seven layers which are termed, in ascending interfacing order, the "physical", "data link", "network", "transport", "session", "presentation" and "application" layers. These layers are arranged to form a protocol "stack" in each node of the network.

FIG. 2 illustrates a block schematic diagram of prior art protocol stacks 225 and 275 used to transmit data between a client node 200 and a server node 250, respectively. The protocol stacks are structured according to the international standards organization OSI seven-layer model, which also standardizes the functions of their constituent layers. Accordingly, only the protocol stack 225 of the client node will be described.

Broadly stated, the physical layer 214 of the OSI model transmits a raw data bit stream over a communication channel 220, while the data link layer 212 manipulates the bit stream and transforms it into a data stream that appears free .of transmission errors. This latter task is accomplished by dividing the transmitted data into data frames and transmitting the frames sequentially, accompanied with error correcting mechanisms for detecting or correcting errors. The network layer 210 routes data packets from a source node to a destination node by selecting one of many alternative paths through the physical network. The transport layer 208 accepts the data stream from the session layer 206, apportions it into smaller units (if necessary), passes the smaller units to the network layer 212, and provides appropriate mechanisms to ensure that all the units arrive correctly at the destination.

The session layer 206 establishes "sessions", i.e., connections, between software processes on the source and destination nodes, and transfers data over those connections in an orderly fashion. That is, a session not only allows ordinary data transport between the nodes, but it also provides enhanced services in some applications, such as dialogue control. The presentation layer 204 performs frequently-requested functions relating to the presentation of transmitted data, including encoding of data into standard formats, while the application layer 202 contains a variety of protocols that are commonly needed by programs executing on the nodes, such as remote file access.

As can be seen in FIG. 2, the protocol stacks 225 and 275 are physically connected through the communications channel 220 at the physical layers 214 and 64. Thus, data transmission over a client-server network consists of generating data messages in the application layer 202 of the client node 200 and passing the data messages down through the protocol stack 225, where they are formatted for delivery onto the channel 220 as bits of packets. Those packet bits are transmitted to the protocol stack 275 of the server 250, where they are passed up that ,,stack to the application layer 252. The generation and formation of data are performed by, inter alia, software programs executing on the nodes. These software programs may be generally categorized into two broad classes: application programs and operating systems. Operating systems are usually specific to a type of computer and consist of a collection of a utility procedures that enable the computer to perform basic operations, such as storing and retrieving information on primary and secondary storage devices, displaying information on an associated video display and, in some cases, performing network operations.

By itself, the operating system generally provides only very basic functions and must be accompanied by an "application" program. The application program interacts with the operating system to provide much higher level functionality and a direct interface with a user of the node. During interactions with the operating system, the application program typically invokes the utility procedures by issuing a series of parameter requests, via standard local procedure calls, to the operating system which then performs the request in accordance with the parameters. For example, the application program may "call" the operating system to store particular data on a computer disk memory or forward the data over the network.

As noted, a significant function of each layer in the OSI model is to provide services to the other layers. Two types of services offered by the layers are "connection-oriented" and "connectionless" network services. In a connection-oriented service, a source node establishes a connection with a destination node and, after sending a message, terminates the connection. The overhead associated with establishing the connection may be unattractive for nodes requiring efficient communication performance. For this latter case, a fully connectionless service is desirable where each transmitted packet carries the full address of its destination through the network.

A remote procedure call (RPC) establishes such a "connectionless session" between a client node and a server node for execution of a specific service. The RPC is typically embedded in software programs to make the remote call appear "local" to the nodes. Client-server communication thus takes the form of procedure calls and the network details are hidden from the application program by placing them in local procedures called "stub" procedures.

FIG. 3 illustrates a typical client-server system 300 wherein the client and server nodes are schematically represented by dotted boxes 305 and 355, respectively. Resident in each node are application programs, represented by boxes 302 and 352, and operating systems, represented by boxes 306 and 356. Interactions between the application programs and operating systems are illustrated schematically by the two-headed arrows 304 and 354. This dual program system is used on many types of computers ranging from mainframes to personal computers.

In order to provide RPC functions, the application programs interact (as shown schematically by arrows 308 and 318) with stub procedure software 310 and 360 by exchanging parameter requests. Each stub procedure, which is generally associated with the operating system, arranges, i.e., "flattens", the parameters into a predetermined message format according to the computer type. An RPC may transfer data or request a server to perform an operation; accordingly, appropriate stub procedure