System and method for establishing a communication channel over a heterogeneous network between a source node and a destination node5719942Abstract A system and method for establishing a communication channel between a source node and a destination node via a heterogeneous communication network comprising at least one intermediate node is disclosed. A request for a communication channel having specified characteristics is issued by the source node to the most immediately adjacent of a possible plurality of intermediate nodes. Each intermediate node determines whether or not it has the available communication resources to support the request. If so, sufficient communication resources are reserved in order to support the request and the request is forwarded to the next intermediate node. The determination by each intermediate node is continued until the destination is reached. After determination by the intermediate node as to whether or not the communication channel can be supported, an indication reflecting the determination is returned to the source node via the intermediate nodes. If a positive indication is received the communication channel is established. Claims We claim: Description This application is related to U.S. application Ser. Nos. 256,211, and 256,209, by Aldred et al both filed Jun. 27, 1994, now U.S. Pat. No. 5,539,886.
______________________________________
system clipboard LPTx
DDE window
shared clipboard printer
serial emulator file
video codec
audio telephone
______________________________________
Shared use of the clipboard is facilitated by the system clipboard and the shared clipboard devices. The system clipboard device may be opened by an application to provide a sending and a receiving port, giving access to the windowing system clipboard data at that node. Only one sending port may exist at any time, but any application at that node may open receiving ports. Through the use of channels, system clipboard data from one node, can be simply routed across to other members of an application sharing set. Another device, the shared clipboard, is provided to ease data sharing. It is unique to a sharing set; only one sending port is allowed but multiple receiving ports are supported. Apart from these distinctions, it behaves in a similar manner to the system clipboard and provides a simple mechanism for applications to share common data. The window device, allows a window, defined on the screen, to be associated with a sending or a receiving port (or in some circumstances both). The sending port can be connected to a channel port and data can be streamed to the window and displayed. A variety of data formats are supported. The DDE device can be opened to provide sending and receiving ports which are coupled to the dynamic data exchange mechanism. Through this device an aware application can control an application that supports DDE, or be itself controlled. Moreover, by establishing the appropriate channels, two remote DDE applications can be linked together. The printer device, allows data robe sent to the system printer; only a single sending port is permitted. The asynchronous serial device supports one sending port and multiple receiving ports and interfaces to RS232, RS422 and other serial communications. A number of video an d audio devices exist including: the video display and playback devices (supporting IBM/Intel ActionMedia II Adapter/A); the video capture device (supporting IBM M-Video Capture Adapter/A); the audio capture and playback devices (supporting IBM M-Audio Capture and Playback Adapter/A); and other specialised audio/video devices (such as H320 compliant codecs). A number of aware applications are shipped as system utilities, and take advantage of these devices to offer general purpose end user functions, for collaborative working over a network. Customisation Customisation information for the support system 17 is stored in an appropriate platform-designated repository; for Windows and OS/2 these are the files called LAKES.INI and LAKESQOS.INI, formatted as a standard ASCII file, containing sections headed by an identifier, where keywords and their values are kept. Applications may also have their own additional initialisation filed. LAKES.INI contains standard section including information on configuration and start-up options, aware applications, devices and physical communications link; additionally application sections containing data specific to those applications may be present. LAKEQOS.INI contains quality of service information relating to physical links and data classes. Calls to access and update these files are provided in the API. Resource Management Collaborative working frequently requires that resources owned by a node, for example a printer device, can be shared with other nodes. Such resources are considered to be global resources and access is controlled through global tokens. Other resources are local to application sharing set, for example a shared pointer, and access to these is managed through application tokens. A token owner determines the significance of a token and allocates it on request. At the discretion of the owner, queued requests may be permitted, and more than one concurrent holder of a particular token may be allowed. Token owners can optionally force holders to hand back tokens. Global tokens share a common name space throughout the network, but since applications are expected to know the location of a globally available resource that they require, duplicate global token names are permitted. Facilities for the broadcasting of availability information are not provided; Instead, the call manager at the node with the global resource is responsible for resource management and therefore holds any global tokens. Global tokens may be held by an application instance on an exclusive or shared basis; token ownership, however, cannot be transferred to an application. Requests for a global token may be queued, with the queue being held above the API and managed by the node call manager. Access to global tokens is not restricted to a sharing application set. Application token name space is restricted to the application sharing set. Tokens may be owned by any member application and ownership can be transferred. Application tokens may be held on an exclusive or shared basis and requests for tokens queued, with the queue being held above the API, and managed by the current application token owner. Initialisation and Termination The support system is started by running a LAKES.EXE file, which reads the profile data from the file LAKES.INI. The named call manager is started by the support system, which then registers itself as an aware application. A "set.sub.-- call.sub.-- manager" command then establishes this particular application as the call manager for that node. After this command, the support system is fully active at that node and is able to process incoming events and requests. Aware applications can be initiated, either by the usual operating system procedures, such as a double click on an icon, or by a "launch" command. In the former case, the application will register with the support system, and in the return data receive its application and node handles. The call manager is notified of this registration, and supplied a handle to the application. In the latter case, the launching application is returned a handle to the application; this is only valid in very restricted circumstances until the launched application has registered with the support system. The return data provides the launched application with its application and node handles. Both the call manager and the application that specified the launch (if different) are notified accordingly. Applications may revert to unaware application status by de-registering, the call manager being notified. All tokens held are released and the token owners are notified; all tokens owned become invalid. If the application is a member of an application sharing set it is removed and the other members notified of its departure. All ports created by the application are destroyed and the other applications owning ports to the affected channels are notified. All channels connected by the terminating application are welded and appropriate events raised at the end channel ports. Appropriate events are raised as necessary to the local call manager, plus the call managers of any nodes supporting a welded channel on behalf of the de-registering application. All open logical devices are closed; if any of the logical devices are connected to ports, destroyed as part of the de-registration process, then the whole connected channel is destroyed and the appropriate events raised. A shutdown request can be issued by an application to close down the support system at a node in an orderly manner. This raises an event in the local call manager, and if the call manager accepts the request, corresponding shutdown events are raised at the other applications. These then prepare to close down and de-register, each de-registration being notified to the call manager. After the call manager has been notified that all the applications have de-registered, it too de-registers, to complete the shutdown. The normal operation of the support system depends on the presence of the call manager. It is possible to replace the existing call manager with another, but the existing call manager may reject the request to do so. Applications may join other applications in a sharing set by issuing the "share.sub.-- app" request and naming an application sharing set; the normal case being where the target application and node are both specified by name. If an application at one node wants to share, by name, with an already existing instance of an application at another node, then the procedure is as follows. App 1 at node 1 issues the "share.sub.-- app" request, specifying its own application and node handles as the source, and the names of app 2 and node 2 as the target. After verification with the call manager at node 1, an appropriate request is sent by the support system to thee all manager at node 2. Providing this call manager accepts the request, this is then passed onto app 2, which can return a confirmation, assuming that it wishes to accept the share. This scheme provides for considerable flexibility in application sharing. Each call manager is aware of the share activity at its node, whether applications are the source or target of "share.sub.-- app" requests. A call manager has the following options on receipt of a share request: (i) handle the share request itself (ii) transfer the share request (iii) reject the share request (iv) launch a new application to handle the share request (v) change the application and node name. An application is not a member of an application sharing set when launched. When the source application issues a "share.sub.-- app" request it has the option of naming the resulting sharing set; if it does not name the sharing set then the target must supply the name. After the share, both the target and the source join a new sharing set with this name. If either the source and/or the target were already members of a sharing set with this same name, then those sharing sets are merged with the newly created sharing set. Applications can leave a sharing set using the "unshare.sub.-- app" request. Data transmission and receipt There are four mechanisms for applications to exchange data: (i) User information strings This is effectively a string passed to the support system as a parameter in an API call, which is then passed to the target application. (ii) Signal function calls These commands allow control information to be sent between applications, and are not restricted to those applications within a single application sharing set. Depending on the API call used, a reply will or will not be provided. Note that since this method uses the communications paths established between support systems on different nodes for their own data control flows, this technique is restricted to light data traffic. (iii) Channel transmission Channels are intended to support the transfer of volume data between applications. They provide the only means of controlling the transport characteristics. The use of channels is restricted to applications within the same application sharing set. When requesting the creation of a channel, the following information is specified: target application handle, channel set type and identifier, data class, maximum buffer size, user exit, node handle, quality of service, connect type, port event handler, user information. An alternative approach to channel creation is to take advantage of the channels created when applications with existing merged or serialised channel set are involved in application sharing. Data is sent over channels by applications in packets; at the physical level the unit of data transmission is a frame. Certain data is spoilable, ie under certain conditions, if it cannot be delivered in time to meet the quality of service requirements, then it may be discarded. Some packets can be marked as spoilable, other packets as spoilers. A spoiler packet, if present, will cause the removal of those spoilable packets with which it has been associated. This technique supports for example the implementation of buffer management schemes for video, where certain packets are delta frame packets, and others are full frame packets. Selected sequences of delta frame packets can and must be deleted if a full frame is available. (iv) logical devices In Certain Specialised situations it is appropriate to use logical devices to exchange data. A single logical device can present ports to multiple applications; the logical device can then move data between the ports. This transport mechanism is not restricted to applications within the same sharing set and therefore overcomes a limitation placed on channels; however logical devices cannot span across nodes. Moreover any necessary quality of service support must be explicitly provided for by the particular logical device. Negotiation of Quality of Service Applications have different needs for quality of service and bandwidth negotiation and control. For examples, the following may be required: pre-determined and constant quality of service, eg G.711 voice flexible requirements at channel creation, but constant thereafter, eg file transfer single application management of channel resources, eg an application communicating multiple data types such as video, voice, and data under restricted bandwidth conditions i.e. the video quality must be degraded intermittently to allow data traffic cross application management of channel resource, eg a group of applications communicating multiple data types under restricted bandwidth conditions and coordinating their activities as the priorities change for different types of data traffic Accordingly, the support system provides for the following: applications to request an indeterminate quality of service and be allocated whatever is dynamically available applications to query what is currently available and request a particular quality of service. applications to manage their own communication resources, the call manager to manage communication resources across applications. For those applications that are satisfied with an indeterminate quality of serive, channels may be established using the a create channel request, LakCreateChannel, leaving the quality of service parameters unspecified. Bandwidth and other characteristics will not be guaranteed by the support system and may change dynamically, depending upon availability. Certain applications have fixed quality of service requirements for the channels needed to communicate with other applications. In these cases the channels may be established directly, using a "create.sub.-- channel" request. Parameters on this request identify the receiving application(s) and both the channel and the sending port characteristics. The resources are allocated by the support system if they are available without any other consideration being taken into account. Likewise, if the channel characteristics are changed or the channel is deleted and the resources which were utilised are returned to the control support system. Some applications are more flexible in their quality of service requirements and need to determine what is available to a particular node before creating a channel and then use this information in setting the parameters of the "create.sub.-- channel" request. This is accomplished through a "query.sub.-- resource" command, specifying the target node. The subsequent "create.sub.-- channel", establishing a channel to that node, can request an equal or lower quality of service and expect the request to be satisfied, if there is not competition for the communications resource. Other applications have flexible quality of service requirements, but need to compromise the specification over a number of channels or need the ability to manipulate the allocation of communication resources. For example, a desktop conferencing application may wish to use the bandwidth available all the time and allocate it to video and audio. However, when data services are required, the application may temporarily re-allocate some video bandwidth to the data service and recover any such allocated resource for the video and audio at a later time. This requires the application to reserve resources and then allocate from this reserved pool. If the channels are requested directly from the support system, there is no guarantee that bandwidth, once relinquished, will be available for the later application. This problem is obviated by using the concept of resource sets. Application can request that the communication resources to a remote node are allocated to an application owned resource set; such resources are identified by the appropriate quality of service parameters. Channels are then allocated from these sets and any resources relinquished are returned to the source set. The application resource request is directed through the local call manager and it acquires the resources from the support system. This also gives the call manager the ability to manage competing requests for resources between applications. An example of the need is the situation that arise when multiple independent applications are involved in a desktop conferencing session, for example: chat, chalkboard, video and audio application. Each of these unaware of the others, but all desire bandwidth to the target node. The call manager coordinates the resource requests from the applications and allocates accordingly. In such a situation the call manager will have acquired the resources before a "share.sub.-- app" request has been issued to the applications at that node so that the resources are reserved prior to the collaborating application instances being activated. The alternative approach is to request the resources after the collaboration has been started. In some cases, the call manager needs to negotiate with application to determine what resources are available and to defer any re-allocation until the negotiations are complete. For example, a movie application starting partway through a call may require a certain minimum bandwidth that is not currently available. Other applications may be already running that, inter se, are using more than that required bandwidth and each also has the ability to be flexible in its usage. The support system provides a set of requests that enable the call manager to ask applications to relinquish bandwidth and then to commit those changes later, if sufficient total bandwidth could be made available. Referring to FIG. 9a, this is achieved by means of a "claim.sub.-- resource" command specifying a resource set identified, a quality of service, and the target node. Application 1 issues a claim resource request identifying the target node, a quality of service and the resource set identifier. The effect of the request is to reserve the requested resources in the named resource set. The identifier can then be specified in a subsequent "create.sub.-- channel" command, in which case the resources are allocated from those reserves. The "query.sub.-- resource" command can be used to determine remaining resources in a resource set. The resources allocated to the APP1 resource set may be sub-allocated by the application using create.sub.-- channel, change.sub.-- channel and add.sub.-- channel function calls, remove.sub.-- channel and change.sub.-- channel, with appropriate parameters, return resources to the set. Each time the claim.sub.-- resource function is issued, the quality of service in the specified resource set is reset to the new values. A query resource request can be used to determine the available resources in a resource set. This provides a mechanism for an application to surrender resources which are no longer needed. Resource set identifiers are local to an application instance and can contain resources appropriate to one particular quality of service. Certain applications need to dynamically change their channel characteristics during execution; for, example, available bandwidth must be re-allocated across channels. This can be done through a "change.sub.-- channel" request, specifying a resource set identifier. The resources are given to, or taken from, those resources associated with that identifier. The above described technique allows, for example, a fixed resource to be secured for communications between applications and then re-allocated dynamically by an application. For example, video bandwidth can be temporarily reduced to allow the temporarily relinquished resources to be used for another purpose, such as a file transfer operation. Cross application management of channel resources A more complex scheme for resource allocation is required when a collection of applications need to share channel resources between two nodes. This requires an application to take on the role of resource management; typically this application will be the call manager. Referring to FIG. 9b, an example of such an approach is given. The call manager, preparing to act as a resource manager, issues a claim.sub.-- resource request, specifying the collaborative working software as the resource manager and identifying the target node, a quality of service and a resource set identifier, for example, CMI. The effect of the request is that the collaborative working software reserves the requested resources in the named resource set. Application 1 then issues a claim.sub.-- resource request, specifying the call manager as the resource manager, and identifying the target node, a quality of service and a resource set identifier, for example, APP1. This results in a RESOURCE.sub.-- CLAIM event being raised in the call manager. This event includes the quality of service parameters now being requested and the existing quality of service parameters present in that resource set, in this case null. The call manager accepts the event and identifies its resource set CM1 as the resource set to be used to satisfy request of the application. This results in the transfer of resources from the resource set CM1, owned by the call manager, to the resource set APP1, owned by application 1. The claim.sub.-- resource call can be used by an application to return resources to the resource manager. Similarly, the resource manager can use this call to ask an application which has been allocated resources to relinquish them. Multiple applications can interact with the resource manager in this way and can be allocated resources from one or more resource sets. In some cases, the resource manger needs to negotiate with applications to determine what resources are available and to defer any re-allocation until the negotiations are complete. This is accomplished using the request.sub.-- resource call. An application of the above is illustrated in FIG. 9c. When the RESOURCE.sub.-- CLAIM event is received from application 1, the call manager, in this example, determines whether or not application 2 can supply the resource. The determination is effected using a request.sub.-- resource function call, raising a RESOURCE.sub.-- REQUEST event in application 2. On return, application 2 indicates whether or not the resources are available. Application 2 should now be prepared to release the resources. At a later time, the call manager asks for the resources using the claim.sub.-- resource function call. This is processed in the usual manner and results in the resources being transferred from application 2 to the call manager. When the call manager completes the processing of the outstanding RESOURCE.sub.-- CLAIM event from application 1, the resources are further transferred from the call manager to application 1. An outstanding RESOURCE.sub.-- REQUEST event can be cancelled by a following RESOURCE.sub.-- REQUEST event requesting a null quality of service, or by a RESOURCE.sub.-- CLAIM event. Networks An application can specify quality of service characteristics when creating a channel or when reserving resource for later allocation to channels. Channels are mapped by the support system onto physical links; two kinds of physical links are relevant: (a) those that allow data packets to be transmitted independently of each other, for example, a token ring local area network and (b) those that allow bit streams to be transmitted, for example, the H.320 protocol. Links are characterised by link type, order, whether switched or fixed, their time-out parameters and by their quality of service characteristics. Link type identifies the link support module (LSM) that is to be invoked to communicate over that link. Order determines the order in which the support system will attempt to use the links for data transmission, assuming that there is a choice of links available with suitable data transmission characteristics. Quality of service information characterises the communication capabilities of the link. For each link type the link selection order, and defaults for the quality of service characteristics, are stored in the configuration profile. Link descriptions which associate remote nodes with link types, and optionally include quality of service characteristics, are stored in an address book external to the support system. The data base is accessed by an installation supplied executable, known as the address book access module. These link characteristics, optionally including quality of service characteristics, are stored in a link data base external to the support system. Defaults for the quality of service information are contained in the initialisation files. The data base is accessed by an installation supplied executable, which is called by the support program. The quality of service parameters relevant to digital links are: throughput, latency, jitter, frame size, frame error rate, frame re-transmission time, compression hints, encryption and priority. Throughput describes capacity in bits per second; latency describes the average delay, in milliseconds, of a data frame; jitter characterises the variation in transmit times for individual frames. The relationship between latency and jitter is illustrated in FIG. 9d. Frame size specifies unit of transmission recovery in bits: for a bit stream network, such as H.320, it represents the H.221 frame size; frame error rate denotes the average proportion of frames that are received with errors, frame re-transmission time describes the average time in milliseconds, to re-transmit a frame, encryption denotes any encryption algorithms in use on the link, and compression hints identifies any compression routines which are to be used in relation to the data. Several of the link quality of service parameters are difficult to quantify. Throughput is fixed for a given configuration over ISDN, ASYNC, FDDI-II and STM links; however it is variable over token ring, Ethernet and FDDI-II. This invariablility can be accommodated by setting the throughput value to a range. Latency and jitter are generally deterministics and values may be approximated at time of use by measurement, for example by "pinging". This variability can be catered for by the use of a range of values or by a "dont know" value. Alternatively, since many network suppliers guarantee their network to operate well enough to meet the requirements for satisfactory audio transmission, then a set of audio values can be used. Error rates present less problems and the network performance can be monitored and these values used or a range supplied. The support system logical channels are also normally associated with quality of service information. This can be set explicitly when the channel is created or can be set implicitly by the use of defaults related to data types and data sub-types. This default information is held in the quality of service profile. Most of the key paramters mirror their link counterparts with the following exceptions: channel priority specifies the order in which the support system will attempt to service data transmissions over all the channels at that node; data size gives the maximum size of a block of data that will be supplied by the application to be sent over the channel; data error rate specifies an acceptable random proportion of the data blocks that need not be delivered due to loss or error in transmission (this is an expected maximum error rate that will be tolerated by the application but conformance to this limit is not guaranteed by the support system. Setting this limit to zero guarantees that the support system will attempt to deliver all data without error, notifying the application in case of failure. The support system uses quality of service and order for available links, coupled with quality of service information for the channels requested by the application, to determine what links to use for application to application communication. A data base containing information such as type of link and service characteristics can be accessed via the resources interface, whilst the channel information is obtained from the application. Referring to FIG. 9e, the address book, external to the support system and accessed via the resource level interface (RLI), contains link descriptions such as: type of link, source and destination nodes, quality of service characteristics, and access parameters. It is possible for all of the physical quality of service parameters to be fully supplied to the support system or, alternatively, for one or more of the values to be defaulted, typically in terms of link type, e.g. the external data my specify the link type and, optionally, one or more of the other parameters. Defaults are resolved via the contents of the configuration profile. If the link is error prone, and error free transmission is required, then the throughput, latency and jitter values are adjusted to reflect the need for frame re-transmission. The individual link values are consolidated to arrive at the physical route quality of service characteristics. Similarly, the quality of service parameters are obtained from the application program, via the channel creation program calls. It is possible for all of the quality of service parameters to be fully specified by the application, or alternatively, for one or more of values to be defaulted, typically in terms of data types and sub-types e.g. the channel creation may specify the data type, sub-type and throughput. Default values are resolved via the contents of an initialisation file (LAKESQOS.INI). A permissible value for latency and jitter is "don't care". The support system then selects an appropriate link to use based upon matching the fully resolved channel requirements with the fully resolved available links information, taking account of (a) the need to exchange control information between the support systems at different nodes, and (b) the order values associated with the links. The parameters are matched as follows: link throughput >=channel throughput, link latency <=channel latency (or "don't known" satisfied by "don't care"), link jitter <=channel jitter (or "don't know" satisfied by "don't care"). Both software and hardware compression and encryption are supported Hardware features on a physical link are accommodated by considering the various combination of options as different available links types, each associated with particular transport characteristics. Software routines can also be used, but these will not be invoked if specific latency and jitter requirements have been set. The quality of service profile contains the necessary information for the support system to decide whether and how compression and encryption should be used. The packet error rate may be used in link selection and operation to determine :(a) whether error checking and retry options should be invoked in links to guarantee packet delivery, and (b) to set time-out values such that a packet arriving later than such a time-out can be deemed lost. These calculations use the link data supplied; there is no subsequent check during the channel re-transmission to determine that the packet error rate is not exceeded. In order that the complex process of route selection can be performed outside the support system if necessary, the RLI calls used to retrieve link information also supply all the required channel quality of service characteristics. Through this mechanism, the address book access module, can itself determine the appropriate route and return that route to the support system together with parameters appropriately set to ensue acceptance. An example of the need for this might be that transmission costs vary with the time of day and should be taken into account in link selection. Channels belonging to synchronisation sets require the data over the constituent channels to be synchronised in time. This can be represented numerically as skew, the average delay in arrival time between packets which should have arrived together. This is illustrated in FIG. 9f. Skew is not explicitly set, but us a consequence of the latency and jitter parameters for individual channels. The support software compensates for channels belonging to the same synchronisation set. Synchronisation points within the data across the channels, can be established through the start.sub.-- sync and stop.sub.-- sync program calls. Link selection with no quality of service considerations If the quality of service characteristics of a channel are left undefined then the support system will select the link to be used taking in account the order information in the LSM owned section of the configuration profile and any available quality of service. Attempts to use channels without reserved resources may need to be queued by the support system. Channel priorities will be used to resolve any resource contentions which arise. A particular resource can be reserved into a pool using the support system claim.sub.-- resource request and supplying the quality of service parameters. Channels can be sub-allocated from this pool using the create.sub.-- channel and other related requests. Such sub-allocations can have undefined quality of service parameters. This approach allows a resource with particular characteristics to be reserved and then over-committed, by being allocated concurrently to multiple channels. If the application controls its use of the channels, an application may use the same resource for different data without having to continually redefine the channels. For example, an ISDN 64 Kbit channel can be used for bursts of voice interleaved with data. The support system requires a control channel to be established between nodes for many requests. If resources have been reserved the support system will normally use these for control data. If no resources have been reserved, then the support system will choose the link type based upon the order information in the configuration profile. Link selection and Passive nodes A channel between nodes can be created over a single physical link or over a plurality of homogeneous or heterogeneous links. The physical connection existing between two nodes is termed a route. The relationship between channels, links and routes is illustrated in FIG. 9g. Establishment of links via passive nodes, where quality of service conditions must be met, is a multi-stage process. In the example of FIG. 9g it can be seen that node B is only accessible via an intermediate node, X. The resource level interface query raised by, for example, the support system at node A to determine whether a link can be established with node B, will identify only the links and associated quality of service connecting node A to node X. The support system at the intermediate node, X, upon determining the intended addressee of the resource.sub.-- request, issues a passive link request to the call manager at node X specifying the quality of service required from node X to node B. The call manager determines whether or not the request for passive working can be supported by checking the availability of resources from node X to node B. If the call manager at node X accepts the passive working request, the support system at node X then uses the resource level interface at that node to determine the appropriate link to use from node X to node B in order to meet the specified quality of service requirements. If such a link is available, the support system at node B decides whether or not to accept the request for a communication channel between it and node A. If the request is accepted at node B, the support system at node A is informed that connectivity to B can be established via the intermediate node X. The quality of service criteria requested by the support system at each passive working node are chosen to ensure the cumulative quality of service over the route is acceptable. Quality of service parameters over a route, r, can be crudely approximated from the link parameters as follows Throughput, T.sup.r =Min.sub.j=1.sup.j=n (T.sub.j.sup.1) Latency, L.sup.r =.SIGMA..sub.j=1.sup.j=n (L.sub.j.sup.1) Jitter, J.sup.r =.SIGMA..sub.j=1.sup.j=n (T.sub.j.sup.1) The calculation of quality of service characteristics through passive nodes also needs to take account the interconnection facilities available at each passive node between links. In many cases these facilities will preclude guaranteed quality of services. A record of the availability of communication resources is kept and managed by the support system at each node. Upon receiving a request for particular resources, the above record is consulted and a determination is made therefrom as to whether the request can be supported. If the request can be supported, the record is updated to reflect the fact that particular resources have been allocated and are no longer available for the duration of an such allocation. Such a record can be realised using any appropriate data structure. For example table 1 below may serve the above functions
TABLE 1
______________________________________
Node Resource % used Resource set using resources
______________________________________
A ISDN 50 APP1, APP2, APP3
B ASYNC 90 APP2, APP4
C ISDN 20 APP2
. . . .
A TCP/IP 10 APP3
______________________________________
It can be seen from table 1, that resource sets APP1, APP2 and APP3 cumulatively use 50% of the ISDN resources between the node containing the table and node A, APP2 and APP4 cumulatively use 90% of the ASYNC resources and APP3 uses 10% of the TCP/IP resources between the node containing the table and node B and so on. When resources are relinquished, the above table would be altered accordingly. For example, if an application using resource set APP1 terminates, the ISDN resources allocated to resource set APP1 would be returned to the pool of resources and the table entry for ISDN would be altered accordingly. Referring to FIG. 9h there is shown a flow diagram illustrating the steps taken when an intermediate node receives a request to support, for example, a passive working request. The request for passive working is received at the intermediate node by the support software at step 900. The request contains an indication of the destination node and the quality of service parameters required for any communication channel to that node. The support system determines whether or not the request can be supported, at step 905, as follows. The support system determines which adjacent node must be contacted in order to reach the destination node. After such a determination, the support system determines whether or not the available communication resources to the adjacent node are sufficient to support the request. The support system searches the table above to make such a determination. For example, if the request was such that ten percent of the Async resources to node B would be sufficient to meet the specified quality of service, the support system would examine the utilisation of resources to node B and note that the required ten percent is available. If the request cannot be supported the intermediate node transmits an indication to the source node of that fact at step 910. If the request can be supported the table entry "B ASYNC 90 APP2, APP4" is updated to reflect the allocation of those resources for the passive working request at step 915. The table entry would therefore be "B 100 APP2, APP4". Therefore, any further requests which would require the ASYNC resources to node B will be refused. Step 920 forwards the passive working request to the next adjacent intermediate node. Acceptance of the passive working request can be acknowledged implicitly when the destination node sends an indication that the request to establish a communication channel has been accepted. Once the passive working request reaches the destination node the above process terminates and acceptance or rejection of the request is sentries the destination node via the intermediate nodes to the source node. Referring to FIG. 9i, there is shown part of a heterogeneous network in which node A is the source node, B to F are intermediate nodes and G is the destination node. The links between the nodes have associated jitter values. For example, the jitter between node A and node B is J.sub.AB. Each node stores an indication of the quality of service parameters associated with every link thereto. Therefore, for example, node A will store an indication the jitter. J.sub.AB and J.sub.AD, associated with the links to nodes B and D. Suppose node A wishes to establish a communication channel to node G having a specified jitter, J.sub.s. The following actions are taken. A) Node A determines which adjacent node it must connect to in order to reach the destination node. It can be seen that either of nodes B or D would suffice. The support system when presented with a choice of nodes may have a list of preferred nodes. Accordingly, if node B is the preferred node, the support system at node A will select node B as the first intermediate node in the route to node G. B) The support system of node A sends a passive working request to node B specifying the destination node G and the required quality of service J.sub.s. C) Node B receives the passive working request and determines the next adjacent intermediate node in the route via which the communication channel can be established. Again suppose that the link to node E is the preferred route and the resources associated therewith are available even though the communication resources to node C are also available. Node B knows that the overall jitter must be less than J.sub.s and that the jitter between node B and the adjacent nodes A and E is J.sub.AB and J.sub.BE respectively. Therefore, then node B forwards the passive working request to node E and the specified quality of service is altered by the support system of node B to be (J.sub.s -J.sub.AB -J.sub.BE). D) Node E receives the passive working request and determines the next adjacent intermediate node in the route via which the communication channel can be established. Again suppose that the link to node G is the preferred route and the resources associated therewith are available. The support system at node E compares the jitter value, J.sub.EG with the jitter value, (J.sub.s -J.sub.AB -J.sub.BE), specified in the request to determine if the link can be supported. If J.sub.EG is less than or equal to (J.sub.s -J.sub.AB -J.sub.BE) then the link can be supported and the request to establish a communication channel to node G is forwarded to that node. E) Node e receives the request to establish a communication channel and the support system thereof determines whether or not to accept the request. An indication of the determination is sent via the intermediate nodes B and E to node A. If at any stage of the above negotiation process, it is determined that an intermediate node cannot meet the specified quality of service the established links are back tracked and alternative routes are explored. For example, suppose the support system at node E detemined that the jitter, J.sub.EG, over the link to node G was such that J.sub.EG was greater than the specified jitter, (J.sub.s -J.sub.AB -J.sub.BE). In such a case the request for passive working would be refused and an indication of the refusal would be send to the intermediate node from which it originated. Originating being used in a relative sense. Therefore, the refusal would be sent back to node B. Upon receiving the refusal, node B would investigate whether or not the passive working request could be supported via an alternative node. In the instant case node C. Negotiation would therefore continue as follows: A) Node C receives the passive working request and determines the next adjacent intermediate node in the route via which the communication channel can be established. Suppose that the link to node G is the preferred route and the resources associated therewith are available. The support system at node C determines whether the jitter, J.sub.CG, is less than or equal to the specified quality of service jitter (J.sub.s -J.sub.AB -J.sub.BE). If so, the request is forwarded to node G as above and node G will respond accordingly. If not, a refusal of the request is transmitted from node C to node B. Node B has exhausted the alternative routes to node G and according sends a refusal of the request to node A. Upon receiving the refusal from node B, node A examines the possible alternative routes and repeats the above process. Therfore, the request would go to node D and to node G via node E depending upon the respective determinations as to whether the specifed quality of service can be provided. When applications with channels share with each other; if their existing channels belong to the same named merged or serialized channel set, the support systems create additional channels. An attest is made to establish these new channels from each sending port, with a quality of service appropriate to that port, ie an implicitly created channel will attempt to have characteristics such that it can transport satisfactorily any data packets expected to be sent down any one of the pre-existing channels from that port. In some cases, due to restrictions imposed by the capabilities of the available physical links, it will not be possible to create channels with such characteristics. However, in all cases a channel will be created, and it is the responsibility of the application program to query the channel capabilities, if these are likely to be significant. A channel between nodes may be realised over a single physical link, or over multiple, serially connected links. The physical connection existing between two nodes is termed a route. a) Permanent Digital Networks The support system operates with either dedicated of shared, switched or permanent, digital links between nodes. Shared links have unpredictable latency and bandwidth characteristics, unless bandwidth management facilities are being employed. Such features give permanent links many of the characteristics of switched connections. b) Permanent Analogue Networks The support system supports analogue communications in a very similar way to digital communications, in those situations where: analogue links exist between nodes. connectivity and routing at each node can be controlled by the system at that node. a digital control channel exists between the nodes. Analogue channels are logically dedicated uni-directional communication links established by the sending application, and they may terminate in more than one receiving application. They may be distinguished from digital channels by signal type value. Ports terminating these analogue channels have a null connect type since they cannot supply or receive data from applications. Only standard or merged channels may be established; serialising and synchronising channel sets are not permitted. Logical devices can present analogue ports when opened; thus a video player device can be used as a source of analogue video and may be connected to an analogue channel through an support system API call. The direct connection of analogue and digital channels is not supported; however certain devices e.g. a codec device could provide both analogue and digital ports when opened and can be used to effect such a coupling. c) Switched Digital Networks Switched digital networks can be used by the support system for inter-node communication without exposing the switched nature of the connection. The support system decides when to terminate an inactive switched digital connection using information in the configuration profile; for a specific connection this can be overwritten by information dynamically supplied through the RLI. Equipment, such as digital telephones, attached to a switched network, are accessed by applications in one of two ways. If a simple connection is all that is required then the telephone may be regarded as a virtual phone application executing at a virtual node. The connection to the phone is initiated by a share request specifying the virtual phone as the target of the share request. The support system will then simulate the appropriate events for the other participants of the share. The effect is that a telephone call will be established between a telephone associated with the local node and the remote telephone. Incoming calls are handled in the same way i.e. as a SHARE.sub.-- REQUEST event coming from the a virtual phoen application at a virtual node. Details identifying the true nature of the communicating device are made available in the user information field. If it is required to control the extra features of the digital telephone, then the phone may be accessed by application through a suitable support system logical device. Thus an ISDN phone device may be written which, when opened, presents receiving and sending ports, with an associated event or command connect type; dialling, and other control functions, are implemented through "signal.sub.-- port" commands. Third party connection between digital telephone equipment is similarly affected through commands to an appropriate device; this may be physically implemented through commands to the local switch. Potentially active multi-point control units, which dynamically modify data or routing, for example, an MCU implementing the CCITT recommendations for audio-visual communication, may also appear as devices to applications. d) Switched Analogue Networks Analogue telephones and other equipment, attached to the public switched network, may be accessed by the support system in a similar manner to digital telephones, i.e. either as a virtual phone application executing at a virtual node, or through a logical device. A PSTN telephone logical device can be written which, when opened, presents a support system port, with a null connect type i.e. it does not supply or receive data from an application. "Signal.sub.-- port" request may be used to control the device. First party connection can be implemented through a modem injecting dialling tones into the local line; third party connection, and multi-way calls through commands to the local switch. The support system determines when to terminate an inactive switched analogue connection using the default information in the appropriate LSM owned section of the configuration profile; for a specific connection this can be overwritten by information dynamically supplied through the RLI. Interfacing to Unaware Applications The support system provides facilities which permit unaware applications to be used for collaborative working. An aware application supplies the user interface dialogue and interacts with the particular unaware application via virtual devices. This same aware application then communicates with a related aware application at the remote node to pass the information to the remote user. Several such applications are included as general purpose utilities. A common requirement is for an application window of an unaware application to be displayed at a remote node as illustrated in FIG. 11. The implementation is as follows: an aware application A.sub.X at node X dialogues with the user to identify the window required, assumed here to be the unaware application U.sub.X. A.sub.X then opens a window display logical device, with the appropriate parameters, the effect of which is to generate a port through which copies of the window data are made available. A.sub.X connects this to a port on a channel leading to an aware application A.sub.Y at the destination node Y. A.sub.Y then opens a real window logical device, and connects the port created to the receiving channel port. Data flows between the nodes, and is displayed at Y, without the further intervention of either application A.sub.X or A.sub.Y. Options available on the windows logical device open request allow the application to specify such parameters as bits/pixel, frequency of update and data format (e.g. text, bit map and option of included pointer position). Remote pointers over the shared window of the unaware application U.sub.X can be handled by A.sub.X and A.sub.Y setting up a channel suitable for the interactive data class. The real pointer on each node is then used for identifying features in the shared window; this can be achieved with an algorithm such as: each user wishing to point moves his pointer into the shared window; when pointers are in the shared window their co-ordinates are transmitted to the sharing applications. The combined co-ordinates are then used to control the pointers; the effect is that whoever moves the cursor last, positions all the linked pointers. Remote printing and remote file generating are similarly accomplished through logical devices. In the case of printing, a printer emulator device is installed at the source node. When it is selected as the printer device by the user, the effect is to redirect the printer data stream to a port. This is then connected, via the aware applications, to a real printer device at the destination node. This general technique is extended for a range of other capabilities such as dynamic data exchange (DDE) and the system clipboard. Remote control of an application or system is not supported directly; however an application to perform remote control can be implemented above the API, with Lakes providing the group communication and multi-media data transmission facilities. Programming Considerations a) Program Call Types and Structure Program calls to the API generally result in a request, indication, response, confirm sequence. An application A, requiring a service, requests that service, supplying the appropriate parameters. The request usually requires another application B being made aware of that request; the mechanism for this is an unsolicited event which appears as an indication at the application B. The action taken by B to the indication event is given to the support system as a response, with appropriate data. The system passes the information back to application A as a confirm event. This is illustrated in FIG. 12 using the example of the sequence involved in adding a port to a channel (for simplicity no parameters are shown). An API call may be either synchronous or asynchronous, depending upon the particular function; a synchronous call returns control when the request is complete, an asynchronous call returns control immediately. To help applications monitor the progress of an asynchronous call, these calls contain a reference identifier. This identifier is valid until the request has been satisfied and queries can be issued to obtain status; this same identifier can also be used to cancel a pending request. All calls pass back a return code denoting call status. b) Addressability An application requests addressability to nodes by using the node name. This name is first passed to the local call manager which has the option to modify it. The resultant name is then used by the support system to determine connectivity information, this requires access to the externally held network and user data base, using the resources interface. Thus the support system determines physical addressability for that name through queries to the network configuration via the resources interface 29, FIG. 2. A node handle is returned to the application to reflect this resolution of the node name. Addressability from one application to another application requires the resolution of an application name. If both applications are at the same node, the local call manager can perform this resolution, else both call managers must be involved. This resolution results in the target application being identified to the source application by an application handle. Calls using application names are always passed to the call manager for resolution; calls using application handle go direct to the specified application. When an application creates a channel, addressability to the channel port is provided through the system returning a port handle. Similarly the opening of a logical device results in a device port handle. All handles are guaranteed to be unique to the using application but are not valid if passed to other applications or nodes. c) Event Classes and Event Handlers API requests are provided to assist with event and call control. A "begin.sub.-- monitor" request allows an application to monitor requests and events at a node, the scope of the monitoring being controlled by the choice of monitor class from one of the following: All: all events or API calls Application Signalling: signal events/API calls Call.sub.-- manager: call manager events/API calls. Data: data transmission events/API calls. Device: device events/API calls. Monitor: monitor events/API calls. Port: port and channel events/API calls. Profile: profile events/API calls. Share: share and unshare events/API calls. Synchronisation: synchronisation events/API calls. Token: token events/API calls. The scope of the monitoring is controlled at the event or API class level. Events can be monitored with or without data. Monitoring is terminated with an "end.sub.-- monitor" command. Applications can also use the "enable.sub.-- events" and "disable.sub.-- events" commands to determine which events they are to receive. The valid event classes are: All: all events Device: device events Port: port and channel events Profile: profile events or API calls Sharing: share request events or API calls A default event handler generates responses for all events not explicitly handled via an applications. Events are handled by registered event handles: four types can exist in aware applications: Application: this is the primary event handler that handles the main events related to the general operation of an aware application. This event handler must be present in all aware applications, including a call manager. Call.sub.-- manager: this is somewhat specialised and handles those events concerned with application registration, name resolution, shutdown requests, passive nodes, call manager transfer, and global token status. This event handler must be present in all call managers. Port.sub.-- event handler: more than one port event handler may be present and each handles data communications related events. Monitor: this is optionally present and handles all monitoring of events. d) Other Programming Facilities All channel ports can be associated with a user exit to monitor data traffic or process data. For a sending port, the user exit is invoked immediately prior to the data being transmitted to the receiving nodes; for a receiving port, the user exit is invoked immediately the data arrives at the receiving port but prior to the data being presented to the receiving application. Specification of a user exit routine on ports which have been connected may impact performance because the data must be surfaced to the user exit. A full set of queries are provided to avoid applications needing to keep track of status information. Application program debugging can be simplified by initially running collaborating applications at a single node; this avoiding physical networks being required during initial stages of program development. No user interface code exists below the API; all user interactions are the responsibility of either the application program, or the code servicing requests across the resources interface. Utilities A number of pre-programmed utilities are provided in order to immediately provide useful function to end users and reduce the programming effort required to develop new collaborative applications, by providing common functions accessible through a command interface. All the utilities are replaceable application programs. The structure of the provided utilities is shown below in FIG. 13. The supplied utilities install as a program group and are designed as a suite of applications which work together. The major utility functions can be invoked from other application programs by means of the "signal" command, as well as directly by the user. a) Directory and Call Management i) Address Book The address book utility 100 allows an end user to add, delete and update directory and connectivity information. The data is stored in a simple file structure which is easily edited by standard programs, although a mechanism is provided to interface with other potentially more extensive and complex address data-bases. User data can be grouped into logical collections known as phone books. The utility interfaces directly to the call manager; it also responds to queries through the resources interface. ii) Call Manager The call manager utility 101 implements the concept of a call. A call refers to a group of users collaborating by using shared applications. More than one call can exist at any time, users can be in more than one simultaneous call, and the same applications can be executed in multiple calls. For example: the users A, B and C can be in a call, x, to review a document; all may using voice communication with each other, A and B may also have a video link, and A and C may also have a shared chalkboard. Meanwhile, A, B and D may be in a second call y, to review a second document; with A and D using a chalkboard, and B and D using voice links. The call concept does not exist in the API but it is implemented by the call manager through application sharing sets. Providing this support avoids the need for aware applications to be involved in call set-up or tear-down and provides clear separation of call management and application programming. The call manager provides dialogues for an end user to select names from the address book and logically establish a multi-point call..Parties can be added and deleted dynamically. Options provided include auto-answer and call barring. One call is deemed to be the current active call and it is the one to which shared applications are normally added when invoked. The current active call may be relegated to the background whilst another call is set-up. b) User Utilities i) Application Assistant This utility implements the following functions for users in a call: direct mirroring of an existing application window, either as a snapshot or continuously, and has the system pointing device enabled as a remote pointer. system clipboard support i.e. the ability for the contents of a system clipboard at one node to be optionally shared and/or viewed at other nodes. remote DDE links able to be established between applications at different nodes. redirection of printing to printers at other nodes. ii) Chalkboard The chalkboard 103 implements a common drawing area with two image planes, which is accessible to all users in a call. The background plane can be loaded from bit-map files, the system clipboard, or from the contents of an application window. The foreground plane can be used for interactive annotation using a range of simple text and graphics tools. Remote pointers over the chalkboard are also supported. iii) File Transfer File transfer 104 allows the transmission of files between users in a call. One or more files can be transferred, the files can be sent with comments, and the original file names are made available to the destination. The receiving node is in full control of file receipt and file naming. iv Message Line Message line 105 provides immediate sharing of text data between users in a call. Multiple simultaneous users are permitted; each participant sees all the exchanged messages, and in the same sequence. The message utility also logs activity during the call; such as calls set-up and terminated, and files transferred. In an actual embodiment this utility is provided as part of the call manager. v) Video/Voice Link This utility 106 allows the establishment of video and voice links between users in a call. The precise function available is dependent upon the capabilities of the physical network and the workstation hardware support. Standards The overall architecture is intended to support a broad range of collaborative applications. The interface is set at as high a level as possible, consistent with not imposing any significant restraints on the range of application models that may be implemented. The nature of the transport networks involved are totally hidden below the API. This means that an application is completely unaware of the network routing (eg direct or indirect), and the network types involved (eg single or multiple links, switched or fixed connections). A consequence of this approach is that the applications must be written expecting that requests, for example for a particular communications quality of service, may fail, since the underlying network may not have the required capability. An agent philosophy has been implemented so that third party applications can be sued to act on behalf of other applications. This permits call manager, telephony, and switching applications to be developed. The current state of technology requires that analog networks and devices should be supported. It is attempted to treat .analog networks like digital networks, in order to ease application migration. At the API level, one of the key concepts exposed is that of applications sharing sets. Applications are expected to collaborate with other applications, and the mechanism for this collaboration is that they join each other in named application sharing sets. The essence of such an application sharing set is that all set members receive information on the status of all the other members; joining a set is the way in which applications declare those in which they have an interest. The concept of the call by contrast exists above the API, and in particular at the call manager. It is possible for different call managers to have different call models. Alongside the application sharing set, the channel is the other fundamental concept in the architecture. Uni-directional channels are used as the basic communications building block to efficiently support both broadcast and two-way communications. The channels are established by the sending application, and accepted by the receiving application, because only the sending application can be aware of the properties of the data which dictate how it should be transmitted. Both applications can independently control the format to be supplied or received to or from their respective ports. Multiple logical channels, for each kind of data flow, allow the support system to allocate the traffic appropriately to the underlying transport network; moreover it lets other applications have data presented to them in separated, homogeneous flows, each individually described. Additionally this split of the inter-application traffic into individual data types, allow the support system to offer data conversion facilities. Connections and welding of channels allows the transport of data to drop below the API so that the application is no longer involved in moving the data. The support system has the option, in some cases, of effecting the connection, either at a very low level at that node, or re-routing the flow away from that node. The support system architecture is designed to permit inter-working between different computer platforms, operate over varied communications networks, and support relevant communication and data standards. The separation of data traffic into logical uni-directional flows of homogeneous data, simplifies the mapping on to a mixed network and allows the use of multiple physical links, of different capabilities, between the nodes. Data multiplexing is handled below the application and can be implemented in different ways depending upon the underlying transport mechanism, e.g. by a combination of: allocating each logical flow to an individual physical link; multiplexing all the data in the support layer; or by leaving aspects of the multiplexing to a device driver. Through this means voice, video and data traffic, for instance, can be sent over multiple channels, over iso-LAN or iso-Ethernet, or over ISDN using the CCITT H320 recommendations. The quality of service requirements impose conditions on the required transport facilities; thus voice and video typically require dedicated physical links or shared links with isochronous capability, implemented through schemes involving priority and bandwidth management. The separate logical data paths provided by channels, with their associated data types, ease inter-application operation because the data components are presented individually, with their nature and format independently available. Through this mechanism, a wide range of existing standards for voice, video, image, file transfer, end coded data can be supported, with the potential for the support system to perform data conversions in the network. The system also provides a separate data class for the interactive objects commonly used in collaborative applications, such as remote pointers, cursors and gestures. Overview of the API Commands The principal facilities offered by the API calls are detailed below. The syntax and parameters of the actual calls is not described because the intent is only to give an overview of the scope. API Function Requests Session and application sharing cancel.sub.-- request: cancels a previous asynchronous request if that request is not already satisfied. deregister.sub.-- app: issued by an application instance to terminate its use of the API. launch.sub.-- app: issued by an application to invoke another application. register.sub.-- app: identifies the issuing application instance as a wire and establishes the application event handler. set.sub.-- call.sub.-- manager: identifies the call manager for that node and establishes the call manager event handler. share.sub.-- app: issued by an application instance to request the sharing of one application with another application. shutdown.sub.-- node: issued by an application instance to request the shutting down of the support system at its local node. unshare.sub.-- app: issued by an application instance to terminate the sharing of one application instance with another application. Devices and Ports add.sub.-- channel: adds, in a specified application instance, another channel to a specified sending port. change.sub.-- channel: changes the specified channel characteristics. change.sub.-- device.sub.-- characteristics: changes the specified device characteristics. change.sub.-- port: changes the specified port characteristics. claim.sub.-- resource: call to a resource manager for resources associated with a particular quality of service. close.sub.-- device.sub.-- port: closes the associated port on the defined device. connect.sub.-- ports: connects a specified receiving port to a specified sending port. create.sub.-- channel: creates a data transmission channel consisting of a sending port at the issuing application and a receiving port at the specified target application. disconnect.sub.-- ports: disconnects the specified receiving port from the specified sending port. open.sub.-- device.sub.-- port: opens a port on a defined device. remove.sub.-- channel: removes the channel associated with the specified receiving port and the specified sending port. request.sub.-- resource: enquiry to a resource manager for resources associated with a particular quality of service. resume.sub.-- port: resumes data transmission through the specified port. signal.sub.-- port: transmits a control string through a specified port. suspend.sub.-- port: suspends data transmission through the specified port after draining or flushing any data not yet received. weld.sub.-- connection: makes the connection of the specified receiving port and the sending port permanent. Data Transmission and Receipt receive.sub.-- data: receives data from the specified receiving command port. send.sub.-- data: sends data asynchronously through the specified sending port. Various transmission acknowledgements may be requested. signal: transmits support system or application defined control data over a support system established control channel to a specified application instance. signal.sub.-- app.sub.-- with.sub.-- reply: transmits support system or application defined control data over a support system established control channel to a specified application instance, and returns the response data. start.sub.-- sync: starts the synchronisation of data received through receiving ports associated with a specified channel set. stop.sub.-- sync: stops the synchronisation of data for all receiving ports associated with a specified channel set. Token Management get.sub.-- token: requests the immediate holding of the specified global or application token either exclusively or in a shared manner. give.sub.-- token: gives the specified token to the specified requester. qget.sub.-- token: requests either the holding of the specified global or application token either exclusively or in a shared manner, or, if the token is not available, the joining of a request queue maintained by the current owner. reclaim.sub.-- token: forces the specified token held by the specified application instance to be immediately released back to the current owner of the token. refuse.sub.-- token: refuses the specified token to the specified requester. release.sub.-- token: releases the specified held token back to the current owner. return.sub.-- token: requests that the specified application instance holding the specified token should return the token back to the current owner as soon as possible. set.sub.-- token.sub.-- owner: sets the owner of the specified token to the specified application instance. Event Control begin.sub.-- monitor: causes special monitoring events identifying each occurrence of an API call, and/or a normal event to be presented to the specified monitoring event handler. default.sub.-- event.sub.-- handler: returns default responses for all events that an application programmed does not wish to handle explicitly. disable.sub.-- events: stops events of the specified event class being passed to the event handler of the issuing application instance. enable.sub.-- events: allows events of the specified event class to be passed to the event handler of the issuing application instance. end.sub.-- monitor: stops the special monitoring events identifying each occurrence of an API call, and/or a normal event being presented. Profile Management read.sub.-- profile.sub.-- string: returns a character string of a specified keyword in a specified section from a profile file. write.sub.-- profile.sub.-- string: copies a character string to a specified keyword in a specified section the profile file. API Queries query.sub.-- address: returns the completed full address of an application instances belonging to a named sharing set. query.sub.-- application.sub.-- status: returns status of an application (unaware, aware or call manager). query.sub.-- channel.sub.-- characteristics: returns the channel characteristics of the channel associated with the specified sending and receiving ports. query.sub.-- channel.sub.-- set: returns the handles of all the ports in a specified channel set. query.sub.-- device.sub.-- characteristics: returns the device characteristics of the specified device. query.sub.-- device.sub.-- status: returns the status of the specified device. query.sub.-- monitor: returns the class of functions or events currently being passed to the monitor event handler. query.sub.-- port.sub.-- characteristics: returns the characteristics of the specified port. query.sub.-- port.sub.-- status: returns the status of the specified port. query.sub.-- resource: returns the resources available in the specified resource set. query.sub.-- sharing.sub.-- set: returns the sharing set identifiers for an application instance. query.sub.-- token.sub.-- holder: returns the owner (application tokens only) and holder of a token. query.sub.-- token.sub.-- state: returns the state of the specified token. API Events Call Manager Events APP.sub.-- DEREGISTERED: an event to the local call manager when the application instance terminates its use of the API. APP-REGISTERED: an event to the local call manager when an application initializes its use of the API. CALL.sub.-- MANAGER.sub.-- ERROR: an error has occurred which affects the call manager. CALL.sub.-- MANAGER.sub.-- REQUEST: art event to the-local call manager indicating that another local application has issued a set.sub.-- call.sub.-- manager function request. NODE.sub.-- SHUTDOWN.sub.-- REQUEST: a request for the support system to shut down. PASSIVE.sub.-- NODE.sub.-- RELEASED: an indication that the resources allocated to allow the node to support passive requests may be released. PASSIVE.sub.-- NODE.sub.-- REQUEST: a request for the node to allocate resources to support a passive request. SHARE.sub.-- REQUEST: a request to share with a named application. TOKEN.sub.-- STATUS.sub.-- REQUEST: a request for status of a global token. Application Events APP.sub.-- SIGNAL: a signal has been received. APP.sub.-- SIGNAL.sub.-- REJECTED: a signal has been rejected. APP.sub.-- SIGNAL.sub.-- WITH.sub.-- REPLY: a signal.sub.-- with.sub.-- reply has been received. APP.sub.-- SIGNAL.sub.-- TRANSFERRED: a signal has been transferred. APP.sub.-- UNSHARE.sub.-- REQUEST: a third party local application has requested that the recipient leave an application sharing set. APP.sub.-- UNSHARED: a notification the issuer is leaving an application sharing set has been received. APP.sub.-- ERROR: a related application error has been detected. NODE.sub.-- SHUTDOWN: a shut down has been initiated. PORT.sub.-- REMOVED: a confirmation that a port has been removed. PORT.sub.-- REQUEST: a request to add a receiving port. RESOURCE CLAIM: raised whenever an application claims its quality of service resources. RESOURCE REQUEST: raised whenever an application requests its quality of services resources. PROFILE.sub.-- CHANGED: an indication that the LAKES.INI or LAKESQOS.INI file has been changed. SHARE.sub.-- CONFIRMED: a confirmation that a share request had processed has been received. SHARE.sub.-- REJECTED: a request to share has been rejected. SHARE.sub.-- REQUEST: a request to share has been received. SHARE.sub.-- TRANSFERRED: a request to share has been transferred. TOKEN.sub.-- CANCEL.sub.-- REQUEST: a request to cancel a queued token request has been received. TOKEN.sub.-- GIVEN: a token has been given to a requester. TOKEN.sub.-- QREQUEST: a request to hold a token or to join the queue if the token is unavailable. TOKEN.sub.-- RECLAIMED: a token has been taken away by owner, TOKEN.sub.-- RECLAIMED: a token has been taken away by owner. TOKEN.sub.-- REFUSED: a request for token has been refused, TOKEN.sub.-- REQUEST: a request to hold a token. TOKEN.sub.-- RETURN.sub.-- REQUEST: the owner of the token requires that the token be returned as soon as possible. Device and Port Events CHANNEL CHANGED: some channel characteristics have been changed. CHANNEL.sub.-- CONFIRMED: a new channel has been created. CHANNEL.sub.-- DESTROYED: a channel has been destroyed. CHANNEL.sub.-- REJECTED: a channel has not been created. CONNECTION.sub.-- WELDED: a weld connection notification has been received. DATA.sub.-- AVAILABLE: data is available at a receiving port. DATA.sub.-- CONFIRMED: a confirmation of a data transmission has been received, or an estimate of the progress of a data transmission. DATA.sub.-- REQUESTED: data is requested from a sending port. DEVICE.sub.-- INFORMATION: an event raised to the sending port event handler of the application instance that is to supply device information. PORT.sub.-- ERROR: a port error has been detected. PORT.sub.-- RESUME.sub.-- REQUEST: a resume port request has been received. PORT.sub.-- SIGNALLED: a signal port event has been received. PORT.sub.-- SUSPEND.sub.-- REQUEST: a suspend port request has been received. PORT.sub.-- SYNC.sub.-- REQUEST: a request to adjust the synchronising control has been received. Monitor Control Events EVENT.sub.-- MONITORED: a notification .of function request and event activities has been received. Channel, Port and Link Characteristics Channel Characteristics The following parameters are associated with a channel and are established on the create.sub.-- channel and add.sub.-- channel requests. quality.sub.-- of.sub.-- service: signal type (analog or digital) throughput latency jitter lateness priority compression hints encryption Quality of service characteristics are associated through data type and subtype in the LAKESQOS.INI file, but can be specified explicitly. They may be left undefined; this allows channels to be created whose operational characteristics depend upon the resources available when data is being sent down the channel. channel.sub.-- type: standard merged serialised synchronised channel.sub.-- set.sub.-- id: identifier Port Characteristics The following parameters are associated with a port; all except port-type are defined explicitly; sending ports specify these parameters on the create.sub.-- channel request, receiving ports specify them on the PORT.sub.-- REQUEST response. connect.sub.-- type: command event null event.sub.-- handler: port.sub.-- type: sending receiving data.sub.-- class: data type data sub-type user.sub.-- exit: user.sub.-- information: Link Characteristics The following quality of service parameters are associated with a physical link and are specified in the network data base accessed via the link locator, or obtained as defaults from the LAKEQOS.INI file. signal type (analog or digital) throughput latency jitter frame size frame error rate frame re-transmission time compression hints encryption Support System Structure Referring back to the support system structure as illustrated in FIG. 10, the various tasks of the components thereof will now be described in more detail. The application manager 223 acts as an interface to the rest of the support system, providing an entry point for all the API calls which are then distributed to the appropriate component after a certain amount of parameter verification. It is also used to scan incoming calls/outgoing events if monitoring is required (see below). The application manager is responsible for calling back the application at the event handler specified when a channel is created. The events will be those raised at the sending port if the local application created the channel, or then receiving port if the remote application created the channel. When creating a port, the application manager passes the address of an event queue handler which will handle all the events for a particular application and place them in a queue. Then, some mechanism such as a dispatch thread continuously reading the event queue sends the event to the application's event handler. The channel manager 227 has five sub-components: a channel supervisor, responsible for starting and shutting down all the other components; a control channel sub-component, which handles control channel communications between support systems at different nodes; a data channel sub-component, which handles all other non-control channel data communications; a node manager, which creates, destroys, and maintains node handles and sets of node handles; and a port manager, which creates, destroys, and manipulates ports and does port query functions. The resource manager 225 is the first component in the support system to get control. It is responsible for initialising all the other components, as well as interfacing to any address book or route selection facilities. The token manager 224, as its name suggests, is responsible for the logging and management of tokens, both global and application tokens (global tokens are owned by the respective call manager components; by contrast application tokens are owned by a node in a sharing set). The device manager 224 is responsible for interactions between the support system and devices, and in particular performs the following functions: resolving devices names to fully qualified path etc, loading appropriate dynamic link library (DLL), generating a record containing the port number, port handler and event word, calling the initialisation entry point, and resolving all entry handles in the DLL to physical address for the application call manager. The signal manager 226 is responsible for signalling to applications (with or without reply) and to ports. Sharing and Call Manager Installation Having now described the overall operation of the collaborative support system, various sharing and call manager set up operations will now be described in more detail. The API command which establishes a call manager is set.sub.-- call.sub.-- manager. The set.sub.-- call.sub.-- manager function requests that the issuer be established as the new call manager at the issuing node and identifies the event handler to be invoked for call manager events. Parameters required by the set.sub.-- call.sub.-- manager functions are:
______________________________________
event.sub.-- handler
the event handler to be invoked for call
manager events.
event.sub.-- word
A user specified data pointer paused to the
call manager event handler on all call
manager events.
call.sub.-- manager.sub.-- info
(returned). The value returned by the current
call manager in response to the
SET.sub.-- CALL.sub.-- MANAGER event.
______________________________________
The set.sub.-- cell.sub.-- manager() fun | ||||||
