BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates generally to managing resources in a telecommunications network or computer system environment.
2. Related Art
Telecommunications network products are services provided by telephone companies that are carried on telecommunications networks. A widely known example is dial-1 long distance voice service which allows a customer to dial a 1 plus a ten digit number from his or her home telephone, talk to a party who answers the telephone on the line of the ten digit number dialed, and pay for the telephone call when billed at the end of the month.
Although dial-1 is popular, other calling and payment options, also referred to as enhanced services, are sometimes preferable. For example, debit calling allows an individual to make a call from a phone other than their home phone and charge the call to the debit account. With debit calling, also referred to as prepaid calling, a customer puts finds in an account and has those funds debited each time a telephone call is made. Another calling and payment option is collect calling in which the call is billed to the receiving party's account.
Enhanced services are not limited to other calling and payment options. Enhanced services can provide a customer with information such as access to news and weather. Another enhanced service is 1-800-MUSICNOW which gives a telephone caller the ability to select and listen to music and then order a recording of the music by entering selections in response to menu prompts using the keypad of the telephone.
Enhanced services are possible because intelligent services networks (ISNs) within telephone companies telecommunications networks have advanced capabilities needed to process the enhanced service calls. The ISNs are networks that comprise ISN components capable of performing enhanced service call processing functions. Exemplary ISN components include computer systems that store data and perform protocol conversion and exchanges, also referred to as switches that route calls. In addition, for processing enhanced service calls, information about customers, calls, and telecommunications services is needed.
The information and ISN components are resources. Within a telecommunications network, resources are sources of assistance in performing functions needed to process calls.
For example, information such as the destination number dialed by a caller provides assistance in call processing by providing the area code which can be translated to determine what telecommunications network circuits should be used by ISN components to route the call to the intended recipient.
Information about resources may be obtained in multiple ways. For example, reports may be available that provide printed information about the resources. In addition, information may be available on-line by a human operator entering commands. Also, alarms may be generated that alert a human system overseer that a particular resource or group of resources is unavailable, malfunctioning, and/or in use more often than recommended. In typical ISNs, information is stored in an automated call distributor (ACD), an intelligent service network application processor (ISNAP), and other ISN components. The ACD provides the call switching, queuing, and protocol conversion functions. The intelligent service network applications processor (ISNAP) provides group selection functionality for the ISN.
Information about the resources is typically stored in electronic format in one or more computer systems. Application programmer interfaces (APIs) may be used to communicate call processing information and information about telecommunications components within a computer program. The APIs are procedures for communication within a computer program that reside in main memory and are processed by a processor. The APIs are used by programmable switches, such as the Excel programmable switch, to perform call processing functions. The API used by the Excel programmable switch is described in a document entitled, “Excel API specification revision 5.0.” Additional APIs include the Tabman, Queman, Sysmem, and Shmman APIs that are described in more detail below.
Typically, information about resources is handled in a non-standard, de-centralized manner. Information about various components within a telecommunications network is accessible via the particular component. For example, central processing unit (CPU) availability of a switch is obtained from the switch. Information about the processing capability of computer systems that assist the switch is stored in memory of the computer systems. In addition, information is only accessible using commands or APIs that can be understood by the component storing the information. For example, to access information about the switch, commands that can be understood by the switch must be used to obtain the data about the switch that is stored within the switch. To access information about a computer system assisting the switch, commands understood by the assisting computer system must be used.
SUMMARY OF THE INVENTION
The present invention is a system and method for managing resources, more particularly ISN resources. Resource management is performed by a resource management routine within an application program that resides in the memory of a switch controller. The resource management routine manages internal switch controller resources and external resources such as programmable switches.
An ISN includes components which perform enhanced call handling functions, such as operator consoles and automated response units, and components that provide access to databases and other networks. Enhanced services, such as pre-paid service, calling card, operator service, 1-800-COLLECT, and 1-800-MUSIC-NOW are possible using the ISN. A switch controller is a telecommunications network component which controls the operation of one or more programmable switches and is capable of performing complex call processing to handle service specific features of enhanced telecommunications services. The switch controller provides an interface between the public switching telephone network (PSTN) and the intelligent service network (ISN).
The present invention is a system-wide approach to resource management. The resource management routine provides standard procedures used by processes to obtain information about resources. In addition, the resource management routine provides controlled access to information about resources. The resource management routine is essentially a protective layer for information about resources. Compared to a library housing books which are resources for people to gain information, the resource management routine is a librarian which controls in a standardized way how resources are accessed by various different processes.
The resource management routine comprises electronic libraries residing in memory of the switch controller that store information about resources and resource management application programmer interfaces (APIs) that are used to access the stored information. Resource management APIs are stored in the main memory and processed by the processor of a computer. In order to process the resource management API, the processor calls the resource management API procedure from main memory. The resource management API procedure executes commands using input data. Completion of the execution of the resource management API results in return data which is the data requested and/or data indicating whether the transaction was successful and an output which is an action requested by the initiating routine.
Resource management APIs are generic in that they are not affected by changes to other APIs or messaging techniques, such as APIs for internal switch controller processing, the Excel programmable switch APIs, or changes to ISN protocols. Having a generic resource management API provides various benefits, including flexibility and extensibility. Flexibility is possible because the resource management APIs are independent of the other messaging techniques. Therefore, resource management does not need to be upgraded with changes to other routines and computer systems. In addition, if a new resource is added, the resource management routine needs to be updated but the new resource has a minimal impact on other routines and computer systems. As a result, changes can be more readily made to the ISN.
In addition, extensibility is improved with generic resource management APIs because new services can be more easily implemented. New services can be more easily implemented because modifications are not needed to the resource management routine unless implementation of the new service involves adding a new resource or modifying a resource such that access to data about that resource is affected. If a new resource is added or an existing resource is modified, changes are needed to the APIs associated with that resource and are not needed system wide.
Furthermore, maintenance and debugging of resource management routines within the switch controller are simplified and more accurate. Maintenance and debugging are simplified and more accurate because resource management APIs are standardized for the various resources. In other words, resource management APIs follow similar procedures when possible although the information is being accessed about different resources. As a result, resolution of maintenance and debugging issues for one resource management API is applicable to other resource management APIs. Also, resource management APIs are grouped within the same resource management routine. Therefore, maintenance and debugging resource management code involves accessing one routine and not attempting to identify resource management functionality within various processes and routines. Furthermore, individual routines are not required to have unique procedures and code for accessing information about resources. In addition to providing standard procedures, the generic resource management routine, which is available to routines requiring information about resources, reduces the overall code required to access resources.
Further features and advantages of the invention, as well as the structure and operation of various embodiments of the invention, are described in detail below with reference to the accompanying drawings.
BRIEF DESCRIPTION OF THE FIGURES AND TABLES
The present invention is described with reference to the accompanying drawings wherein:
FIG. 1 is a block diagram of an exemplary embodiment of a resource management environment according to one embodiment of the present invention;
FIG. 2 is a block diagram of the hardware configuration of a switch controller according to one embodiment of the present invention;
FIG. 3 is a flowchart of a resource management environment according to one embodiment of the present invention;
FIG. 4 is a block diagram of a resource management interface according to one embodiment of the present invention;
FIG. 5 illustrates the operation of a resource management process flow according to one embodiment of the present invention;
FIG. 6 is a diagram of an exemplary embodiment of resource management according to one embodiment of the present invention; and
Tables 1-69 illustrate application programmer interfaces and data structures according to one embodiment of the present invention.
In the drawings like reference numbers generally indicate identical functionally similar and/or structurally similar components. The drawing in which an element first appears is indicated by the left most digits in the corresponding reference number.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
1.0 Overview
Resource management within a switch controller provides management of intelligent service network (ISN) resources. A resource management routine within an application program residing in the memory of the switch controller manages resources by providing a protective layer of standard procedures, referred to as resource management application programmer interfaces (APIs) that are used to access information about ISN resources. The information about the ISN resources is stored electronically in memory and is organized in table format. The electronically stored data is referred to as the resource manager tables.
The ISN resources are resources associated with an ISN. An ISN is a network of components that perform functions to provide enhanced services, such as pre-paid service, calling card, operator service, 1-800-COLLECT, and 1-800-MUSIC-NOW. The ISN resources are sources of assistance in performing functions to provide enhanced services. The ISN components, such as operator consoles and automated response units, provide capabilities needed to process enhanced service calls and are ISN resources. In addition, information related to call processing is also an ISN resource.
The resource management routine resides within the memory of a switch controller. A switch controller is a telecommunications network component which provides an interface between the public switching telephone network (PSTN) and an intelligent service network (ISN). The switch controller provides control over ISN components, including one or more programmable switches, manual operator consoles, and automated response units (ARUs). In addition, the switch controller is capable of performing complex call processing to handle service specific features of enhanced telecommunications services.
The resource management routine comprises electronic libraries referred to as resource manager tables residing in memory of the switch controller that store information about resources and resource management application programmer interfaces (APIs) that are used to access the stored information. Resource management APIs are stored in the main memory and processed by the processor of a computer. In order to process the resource management API, the processor calls the resource management API procedure from main memory. The resource management API procedure executes commands using input data. The resource management API returns a response message that includes requested information and/or indication of whether the transaction was successful. The resource management API also results in an action requested by the initiating routine.
2.0 Example Resource Management Environment
FIG. 1 is a block diagram of an exemplary embodiment of a resource management environment 102 according to one embodiment of the present invention. The switch controller 112 within the ISN 126 provides access for a call initiated via telecommunications switching network 108 to ISN components 122 a, 122 b, . . . 122 n also within ISN 126. Except as otherwise noted, when the ISN components 122 are referred to generally, they will be referred to by number designation only and not a letter designation. The resource management routine which resides in memory of the switch controller 112 provides management of ISN 126 resources. The ISN 126 is described in further detail in copending U.S. Patent Application Ser. No. 09/096,936 entitled, “Intelligent Service Network,” incorporated by reference herein in its entirety.
The ISN environment 102 includes telephone 104 used by a caller, a telecommunications switching network 108, and an ISN 126. The telephone 104 used by the caller is connected to telecommunications switching network 108. The telecommunications switching network 108 provides switching and connectivity to the ISN 126. The ISN components 122 provide enhanced service call processing and connectivity to external networks and resources. Enhanced services include manual operator service, prepaid calling, calling card, 1-800-COLLECT, and 1-800-MUSICNOW. External networks and resources include financial processors, information databases, and Internet facilities.
The ISN 126 includes a programmable switch 110, a switch controller 112, LANs, WANs, and routers 120, and ISN components 122. The programmable switch 110 is connected to the telecommunications switching network 108 to provide switching capabilities for access to the ISN 126. The switch controller 112 is interconnected to programmable switch 110 to provide commands to control the programmable switch 110. The LANs, WANs, and routers 120 are connected to switch controller 112 and the ISN components 122 to provide connectivity between the switch controller 112 and the ISN components 122. Exemplary ISN components 122 include manual operator consoles (MOCs), automated response units (ARUs), databases, and protocol converters. The MOCs and ARUs are personal computers (PCS) that interact with a caller to provide operator services, customer services, and other enhanced services. Databases contain stored information and may be a single database or multiple databases connected to and controlled by a server systems. Protocol converters are connected to external networks and resources and provide protocol conversion and other processing necessary for interface between the telecommunications switching network 108 and external networks and resources.
The exemplary embodiment of a resource management environment 102 can best be described referencing the processing of a typical call. The exemplary call will be for a service that requires human operator intervention. The call is placed by a caller using telephone 104. The call is received by telecommunications switching network 108. The telecommunications switching network 108 comprises multiple telecommunications networks including local exchange networks and interexchange networks. A local exchange network comprises switches and termination equipment within a localized area An example of a local exchange network is a local telephone operating company network, such as Bell Atlantic. An interexchange network comprises a plurality of switches, also referred to as exchanges, distributed throughout a geographic area large enough to process long distance telephone calls. For example, a national interexchange network comprises switches located throughout the nation. When the call is routed to either a local exchange network or an interexchange network, the call is routed to one or more switches within the network.
The telecommunications switching network 108 is interconnected to the programmable switch 110 within the ISN 126. The programmable switch 110 has a basic switching matrix that provides switching functionality for access to the ISN 126. An ISN 126 may include additional programmable switches (not shown) interconnected to switch controller 112 or to additional switch controllers (not shown). The programmable switch is a dumb switch that can connect ports and process calls based on external commands. Examples of programmable switches include those built by Excel and Summa Four. Excel programmable switches come in sizes ranging from 512 ports to 8,000 ports.
The ISN 126 has a sizable architecture because the number of programmable switches 110 and the configuration of the programmable switches 110 can vary depending on the desired port requirement of the ISN 126. Excel programmable switches can support various signaling systems such as Signaling System Number 7(SS7) and can be connected directly to the signaling network of a telecommunications switching network 108. If multiple programmable switches are interconnected to one or more switch controllers, connections between the programmable switches and the switch controllers are most likely via a LAN (not shown), such as an Ethernet LAN, using transmission control protocol/internet protocol (TCP/IP). Transmission control protocol/internet protocol is used by various data networks including many Internet servers. Each programmable switch 110 is connected to the telecommunications switching network 108 via voice telephony trunks, also referred to as lines. Typical telephony trunks are capable of carrying high speed digital data. The voice trunk connectivity between the programmable switch 110 and the telecommunications switching network 108 includes signaling, such as SS7 protocol. The current industry standard of SS7 protocol is published in the International Telecommunications Union (ITU) Signaling System Number 7(SS7) Integrated Services Digital Network (ISDN) User Part (ISUP) NCT1.113(1995) document and the International Telecommunications Union (ITU) Signaling System 7(SS7) Message Transfer Part (MTP) NCT 1.111(1992) document which are incorporated herein by reference in their entirety. Signaling System 7 may be implemented using SS7 signaling rings (not shown) connected to a signal transfer point (not shown). Some ISN 126 architectures may use signaling gateways between the signaling transfer point and the programmable switch although this is not necessary if the programmable switch is capable of the signaling used by the telecommunications switching network 108.
Switch controller 112 is connected to programmable switch 110 to provide external commands to control call processing. The switch controller 112 provides the commands to the programmable switch 110 to perform call processing functions. When the programmable switch 110 receives a call from the network it sends a message to the switch controller 112. The switch controller 112 determines the call processing needed and returns commands to the programmable switch 110.
In addition, the switch controller 112 provides access to ISN components 122. The switch controller interfaces with ISN components 122 via LANs. WANs, routers (or any other connectivity) 114 using Network Information Distribution System (NIDS) Sequenced Packet Protocol (NSPP) on top of User Datagram Protocol/Internet Protocol (UDP/IP). Network Information Distribution System Sequenced Packet Protocol is a session oriented packet exchange protocol that is implemented over UDP/IP. It is designed to allow rapid information exchange between client applications and NIDS server processes. The use of TCP/IP between switch controller 112 and the programmable switch 110 and the use of NSPP/UDP/IP for communications via LANs, WANs, routers (or any other connectivity) 114 illustrate exemplary protocols but the ISN 126 is not limited to these protocols.
Stored within memory of the switch controller 112 is the switch controller application program 118 which is the computer program that performs the functionality associated with switch controller 112. The switch controller application program 118 is processed by a processor. The architecture of the switch controller 112 will be described in further detail with respect to FIG. 2.
The resource management routine 114 resides in memory of the switch controller 112 within the switch controller application program 118. In one embodiment of the present invention, the resource management routine is within a resource control function. The resource control function is a process within the switch controller application program 118 that both provides management of resources and monitors resources. Resources are managed by the resource management routine 114. Monitoring is performed by a system control process, also within the resource control process. The system control process monitors call states and service related resources.
Switch controller application program routines 116A, 116B, 116C, . . . 116 n reside in memory of the switch controller 112 within the switch controller application program 118 and, when executed, perform enhanced service call processing and other functions needed to provide an interface between the telecommunications switching network 108 and the ISN components 122. Except as otherwise noted, when the switch controller application program routines 116 are referred to generally, they will be referred to with the number designation only and not a letter designation. The routines within the switch controller application program 118 include the resource control function (described above), the programmable switch support function, the call control function, the service control function, and the management interface function.
The programmable switch support function provides an interface between the switch controller 112 and the programmable switch 110. The programmable switch support function translates messages between a generic switch controller API message format and programmable switch API message format, manages message header/trailer requirements, and controls connectivity to the programmable switch 110.
The call control function provides service independent call processing. The call control function performs call processing by analyzing call processing information with respect to the current state as defined by the basic call state machine model. Each call has two states represented in the state machine for the originating and terminating call segments. The basic call state machine model is described further in the International Telecommunications Union (ITU) specifications Q.1224. The call control function performs various functions including but not limited to: detecting an incoming call, creating an originating call model, collecting originating dial digits, requesting analysis of the digits, selecting trunk groups, creating a terminating call model, composing and sending messages to the terminating agent or party, detecting ISUP messages, detecting disconnect signals, and triggering enhanced services.
The call control function trigger features and services from the service control function. The service control function provides an interface to the ISN 126 and one or more service logic programs that provide enhanced service call processing. The service control function is made up of the switch service process, the group select process, call queuing process, and the prepaid service logic process. In order to provide an interface to the ISN 126, the switch service process connects between SCAPI used by the switch controller and NSPP used by ISN 126.
The management interface function includes two functional areas of monitoring control. The system monitoring functionality encompasses the generation of system alarms which allows a system management console to monitor the status and run-time operation of the switch controller software. The management interface function also includes the process manager, which is responsible for initial startup and health of individual processes which make up the switch controller 112.
The ISN components 122A, 122B, . . . 122 n (122) include components that provide enhanced service functionality call and connectivity to external networks and resources. Except as otherwise noted, when the ISN components 122 are referred to generally, they will be referred to with the number designation only and not a letter designation. One example of an ISN component 122 is the MOC. The MOC is PC workstation that is operated by a live operator or call center agent to provide operator services, customer services, and other enhanced services requiring human operator intervention. Another example of an ISN component 122 is the ARU. The ARU is comprised of a network audio server (NAS) and an automated call processor (ACP). The ARU is used to provide automated operator services and interactive voice response services. The ACP is a high performance personal or midrange computer that performs intelligent application processing to determine which services to provide. The NAS is a specialized computer equipped with telephony ports which provides audio responses and collects caller input via dual tone multifrequency (DTMF) signals and voice recognition based on commands provided by the ACP. The ACPs communicate with the NASs via LANs, WANs, and routers 120. Each ARU/NAS and MOC is connected to one or more programmable switches via voice trunks (not shown). Both MOCs and ARUs are also referred to as agents.
An additional example of an ISN component 122 is a NIDS server and database. A NIDS server and database stores data related to call processing such as customer accounts and routing translations. When an ISN component, such as an ARU or a MOC, receives a call, it may query a NIDS server for data stored in the NIDS database. The NIDS servers receive data from mainframe-based systems to be used during real time call processing. Order entry and data management functions are performed within mainframe based systems. Mainframe computers are used as the databases of record for call processing data. A data distribution system (DDS) distributes the call processing data stored in the mainframe computers over a token ring LAN to each NIDS server.
The ISN components also include protocol converters that convert between various telecommunications protocols. Protocol converters provide protocol conversion between different protocols such as TCP/IP, NSPP on top of UDP/IP, and packet switching protocols, such as X.25. Exemplary components that perform protocol conversion are described in U.S. patent application Ser. No. 08/967,339 filed Oct. 21, 1997 entitled, “Advanced Intelligent Network Gateway” and U.S. patent application Ser. No. 08/956,220 filed Oct. 21, 1997 entitled, “Validation Gateway,” both of which are incorporated herein by reference in their entirety. Additional ISN components 122 are described in copending U.S. patent application Ser. No. 08/956,232 filed Oct. 21, 1997 entitled, “A System and Method for Providing Operator and Customer Services for Intelligent Overlay Networks,” incorporated herein by reference in its entirety.
Additional ISN components 122 include standalone PC workstations for system management, force management and configuration provisioning.
Some ISN components 122, such as protocol converters, are connected to external networks and resources. Exemplary external networks and resources include financial processors with credit card information, the Internet, and other databases, such as those used in processing international calls.
3.0 Resource Management within the Switch Controller
The switch controller application program 118 of the present invention is preferably implemented using a computer system 202 as shown in block diagram form in FIG. 2. The computer system 202 includes one or more processors such as processor 206 connected to bus 204. Also connected to bus 204 is main memory 208 preferably random access memory (RAM) and secondary storage devices 210, secondary storage devices 210 include for example a hard drive 212 and a removable storage medium storage device 214 such as a disk drive.
The switch controller application program 118 is preferably a computer program that resides in main memory 208 while executing. Thus, the switch controller application program 118 represents the controller of the computer system 202 (and of the processor 206). Alternately, the switch controller application program 118 is predominantly or entirely a hardware device such as a hardware state machine.
In one embodiment, the present invention is a computer program product such as removable storage medium 216 representing a computer storage disk, compact disk etc., comprising a computer readable media having control logic recorded thereon. The control logic, when loaded into main memory 208 and executed by processor 206, enables the processor 206 to perform operations as described herein. The switch controller application program 118 includes commands which comprise the resource management routine 114 which, in one embodiment of the present invention, reside in main memory 208 and are processed by the processor 206.
FIG. 3 is a block diagram of a resource management environment 302 according to one embodiment of the present invention. The block diagram of a resource management environment 302 illustrates the protective layer concept of the resource management routine 114. Within the resource management routine 114 are resource managers 304A, 304B, 304C . . . 304 n (304). Resource requesters 306A, 306B, 306C . . . 306 n (306) obtain information about resources 310A, 310B, 310C . . . 310 n (310) by communicating with the resource managers 304. Thus, the resource managers 304 provide a protective layer for the resources 310. Except as otherwise noted, when the resource managers 304, resources 310, and resource requesters 306 are referred to generally, they will be referred to with the number designation only and not a letter designation.
The resource management routine 114 comprises the resource managers including resource manager (1) 304A, resource manager (2) 304B, resource manager (3 ) 304C, and resource manager n 304 n.
Resources 310 include the equipment comprising the ISN 126 and enhanced service call processing information. Equipment comprising the ISN 126 includes the components comprising the programmable switch 110, components comprising the switch controller 112, and ISN components 122. Examples of components comprising the programmable switch 110 are ports, central processing unit (CPU) capacity, switch matrix, etc. Examples of components comprising the switch controller 112 are CPU capacity, shared memory capacity, etc. In addition, enhanced service call processing information is a resource 310. Enhanced service call processing information includes information about enhanced service calls, such as call identification numbers, leg identifiers, billing time points, etc.
Resource requesters 306 include the switch controller application program routines 116 (system control process, programmable switch support function, call control function, service control function, and management interface function). In addition, any routine in a computer program in a telecommunications network. component that can access the resource management routine 114 may be a resource requester 306.
Each resource manager 304 provides a protective interface for a particular corresponding resource 310. For example, resource manager (1) 304A provides a protective interface for resource (1) 310A. If a resource requester 306 wants information about a resource 310, the resource requester interfaces with the appropriate resource manager 304. For example, FIG. 3 illustrates resource requester (3) 306C requesting information from both resource manager (1) 304A to gain information about resource (1) 310A, and resource manager (3) 304C, to gain information about resource (3) 310C. If resource requester (3) is the service control function, the service control function may request information about agents and call data block information. The service control function would access a resource manager for information about the agents and another resource manager for information from the call data block.
Multiple resource requesters 306 may obtain information about a resource 310 by accessing the appropriate resource manager 304. For example, resource requester (1) 306A and resource requester (2) 306B request information from resource manager (2) 304B to gain information about resource (2) 310B. If the programmable switch support function and the management interface function need information about a component of the programmable switch 110, both routines access the resource manager 304 corresponding to the programmable switch component 110.
FIG. 4 is a block diagram of a resource management interface 402. The resource management routine 114 provides the resource management interface 402. The resource management interface 402 illustrates that in order to access information about a resource 310, a resource requester 306 accesses the appropriate resource manager 304. Exemplary resource requester (1) 306A accesses resource manager (2) 304B to obtain information about a corresponding resource (2) 310B. If exemplary resource requester (1) 306A needs information about resource (1) 310A or resource n 310 n, the resource requester (1) 306A will access the corresponding resource manager 304, particularly resource manager (1) 304A or resource manager n 310 n respectively. As a result, information about resources 310 is accessed in a standardized manner by each of the resource requesters 306. In addition, the resource requesters 306 are not required to have individual procedures for accessing information about resources 310. Rather, the resource requesters 306 use the generic procedures within the resource manager 304.
Each resource manager 304 includes one or more resource manager application programmer interfaces (APIs) 404 and one or more resource manager tables 406, referred to interchangeably as electronic libraries. For example, resource manager (1) 304A includes resource manager API(s) (1) 404A and resource manager table(s) (1) 406 a; resource manager (2) 304B includes resource manager API(s) (2) 404B and resource manager table(s) (2) 406B; and resource manager n 304 n includes resource manager API(s) n 404 n and resource manager table(s) n 406 n. Except as otherwise noted, when the resource manager APIs 404 and resource manager tables 406 are referred to generally, they will be referred to with the number designation only and not a letter designation.
The resource manager tables 406 reside in memory of the switch controller and store information about resources 310. The resource management APIs 404 are procedures that are used to access the stored information. Resource management APIs 404 are commands that are stored in the main memory and processed by the processor of a computer. In order to process a resource management API 404, the processor calls the resource management API 404 from main memory. The resource management API 404 processes by executing commands using input data. Completion of the execution of the resource management API 404 results in return data which is the data requested and/or data indicating whether the transaction was successful and an output which is an action requested by the initiating routine.
FIG. 5 illustrates the operation of resource manager process flow 502. In step 506 the resource requester sends a query to the appropriate resource manager 304 using the resource manager API 404. For example, as shown in FIG. 4 resource requester (1) 306A would send a query using the resource manager API (2) 404B to resource manager (2) 304B to access information in resource manager tables (2) 406B. The switch controller uses UNIX interprocess communications (IPC) capabilities in order to facilitate communication among the routines of the switch controller. Particularly, UNIX IPC queues and shared memory capabilities are used.
Switch controller application program routines 116 send queries to well known IPC queues. The queries contain a reference pointer to shared memory. The shared memory is dynamically allocated and contains data needed to perform the resource manager API 404 request. The processor 206 (shown in FIG. 2) executes the resource manager API 404 commands residing in memory which preferably is main memory 208 but may be secondary memory 210 including hard disk 212 or a removable medium 216. In the example above, the processor executing the resource manager (2) API 404B commands generates a query which is sent from the resource requester (1) 306A (shown in FIG. 4 and FIG. 3) to a queue associated with resource manager (2) 304B. The queue includes a reference pointer to shared memory with data needed to retrieve information about the resource 310.
For example, if the resource requester 306 is the call control function, an exemplary communication is the call control function writing call information to the call data block. In the example, the call information is the resource (2) 310B. The call control function will send a query using the call data block resource manager API 404 to set information in the call data block. The call data block is the resource manager table 406.
In step 508 data is retrieved or updated in the appropriate resource managers table 406. In order to retrieve data from or update a resource manager table 406, the resource manager 304 retrieves the reference pointer contained in the query that was sent in step 506, accesses the shared memory pointed to by the reference pointer, and retrieves data from shared memory needed to retrieve data from or update the resource manager table 406. In the example illustrated in FIG. 4, the resource manager (2) 304B retrieves the reference pointer in the query sent by resource requester (1) 306A in step 506, accesses the shared memory pointed to by the reference pointer, and retrieves the data from shared memory needed to retrieve data from or update the resource manager table (2) 406B.
After retrieving the data from shared memory, the resource manager 304 performs the requested resource manager API 404 procedure which involves retrieving information from or updating the resource manager table 406. In the example illustrated in FIG. 4, the resource manager (2) 304B performs the resource manager API (2) 404B procedure and retrieves information from or updates resource manager table (2) 406B.
For an exemplary request by the call control function to write information to the call data block, the call data block resource manager will retrieve the reference pointer from the query sent by the call control function (which is the resource requester 306). The call data block resource manager will access shared memory pointed to by the reference pointer and retrieve the data from shared memory to retrieve data from or update the call data block, which is the call data block resource manager table. Exemplary data includes a call identifier that can be used to access the call data block information for a particular call. The call data block resource manager will write the data to the call data block. The call data block resource manager API and call data block table will be described in further detail with respect to FIG. 6.
To ensure that multiple resource requesters 306 do not access the same information within a resource manager table 406, a semaphore variable is set if a resource requester 306 is accessing information. A semaphore variable is a variable that has two possible values, one value indicating that data may be accessed and another value indicating that data may not be accessed. Semaphore variables may control access of a table or of just one data element within a table. Semaphore variables are resources as they are needed for enhanced service call processing. Procedures for retrieving information about or updating semaphore variables are defined by the semaphore variable APIs. Information about semaphore variables, such as the value of the variable, is stored in a semaphore variable table.
In step 510 the resource manager 304 responds using the resource manager API 404. Completion of the execution of the resource manager API 404 results in return data which is the data requested and/or data indicating whether the transaction was successful. Also, the completion of the execution of the resource manager API 404 may result in an output, which is an action requested by the initiating routine. Neither return data nor output is necessary for successful processing by the resource management API 404 but may be useful in providing data and/or ensuring a transaction completed successfully.
Exemplary Resource Management Embodiment
A. Overview
FIG. 6 is a block diagram 602 of an exemplary embodiment of a resource management 114. Resource management 114 includes numerous resource managers 604-622. In one embodiment, these resource managers include the tabman resource manager 604, queman resource manager 606, sysmem resource manager 608, shmman resource manager 610, semaphore resource manager 612, switch controller resource manager 614, agent resource manager 616, call data block resource manager 618, service logic program resource manager 620 and switch resource resource manager 622. These various resource managers are described in further detail in Tables 1-69.
|
1.0 |
Tabman Resource Manager 604 |
|
|
|
API Tables |
|
|
Tabman Client Table APIs |
Table 60 |
|
|
Tabman Service Descriptor APIs |
Table 61 |
|
|
Tabman Service Table APIs |
Table 62 |
|
|
Other Tabman APIs |
Table 63 |
|
|
Data Structure Tables Tabman Client Table |
Table 67 |
|
|
Data Structure |
|
|
Tabman Service Descriptor Table Data |
Table 68 |
|
|
Structure |
|
|
Tabman Service Table Data Structure |
Table 69 |
|
2.0 |
Queman Resource Manager 606 |
|
|
API Table |
|
|
Queman APIs |
Table 64 |
|
3.0 |
Sysmem Resource Manager 608 |
|
|
API Table |
|
|
Sysmem APIs |
Table 65 |
|
4.0 |
Shmman Resource Manager 610 |
|
|
API Table |
|
|
Shmman APIs |
Table 66 |
|
5.0 |
Semaphore Resource Manager 612 |
|
|
API Table |
|
|
Semaphore APIs |
Table 1 |
|
6.0 |
Switch Controller Resource Manager 614 |
|
|
API Tables |
|
|
Switch Controller Common Library Memory |
Table 2 |
|
|
Segment APIs |
|
|
Operational Measurements Area APIs |
Table 3 |
|
|
Heartbeat Table APIs |
Table 4 |
|
|
Data Structure Tables IPC Table |
Table 12 |
|
|
Switch Controller CPU Availability |
Table 13 |
|
|
Switch Controller Disk Availability |
Table 14 |
|
|
Queman APIs |
Table 64 |
|
3.0 |
Sysmem Resource Manager 608 |
|
|
API Table |
|
|
Sysmem APIs |
Table 65 |
|
4.0 |
Shmman Resource Manager 610 |
|
|
API Table |
|
|
Shmman APIs |
Table 66 |
|
5.0 |
Semaphore Resource Manager 612 |
|
|
API Table |
|
|
Semaphore APIs |
Table 1 |
|
6.0 |
Switch Controller Resource Manager 614 |
|
|
API Tables |
|
|
Switch Controller Common Library Memory |
Table 2 |
|
|
Segment APIs |
|
|
Operational Measurements Area APIs |
Table 3 |
|
|
Heartbeat Table APIs |
Table 4 |
|
|
Data Structure Tables |
|
|
IPC Table |
Table 12 |
|
|
Switch Controller CPU Availability |
Table 13 |
|
|
Switch Controller Disk Availability |
Table 14 |
|
|
Agent Operational Measurement Counts |
Table 15 |
|
|
Switch Port Operational Measurement |
Table 16 |
|
|
Counts |
|
|
Control Table for Heartbeat Table |
Table 17 |
|
|
Heartbeat Table |
Table 18 |
|
7.0 |
Agent Resource Manager 616 |
|
|
API Table |
|
|
Agent Memory Segment APIs |
Table 5 |
|
|
Agent Table APIs |
Table 6 |
|
|
Group Table APIs |
Table 7 |
|
|
Assignment Table APIs |
Table 8 |
|
|
Data Structure Table |
|
|
Control Table for Agent Table |
Table 19 |
|
|
Agent Table |
Table 20 |
|
|
Agent Attributes Table |
Table 21 |
|
|
Agent Time Stamps Table |
Table 22 |
|
|
Agent Counts Table |
Table 23 |
|
|
Control Table for Group Table |
Table 24 |
|
|
Group Table |
Table 25 |
|
|
Calls Queued Per Group Table |
Table 26 |
|
|
Control Assignrnent Table |
Table 27 |
|
|
Assignment Table |
Table 28 |
|
|
Assignment Data Table |
Table 29 |
|
|
Mapping Table |
Table 30 |
|
|
Fast Search for Agent Table |
Table 31 |
|
|
Group Search Table |
Table 32 |
|
|
Line Card Table |
Table 43 |
|
|
CPU Card Table |
Table 44 |
|
|
DSP Table |
Table 45 |
|
|
SIMM Table |
Table 46 |
|
|
MFDSP Table |
Table 47 |
|
|
Stack Table |
Table 48 |
|
|
Linkset Table |
Table 49 |
|
|
Link Table |
Table 50 |
|
|
Destination Table |
Table 51 |
|
|
Route Table |
Table 52 |
|
|
SS7 Table |
Table 53 |
|
|
EXNET Table |
Table 54 |
|
|
Facility Table |
Table 55 |
|
|
Charmel Table |
Table 56 |
|
|
ISDN Card Table |
Table 57 |
|
|
Other Card Table |
Table 58 |
|
|
Card Union Table |
Table 59 |
|
|
C. Description of Exemplary Resource Manager
The call data block resource manager 618 is described with respect to Table 9 to provide an exemplary illustration of the information contained in the tables. The call data block resource manager 618 comprises call data block APIs and call data block resource manager tables. Call data block APIs are described in Table 9. Call data block APIs provide procedures for managing call data block information. Call data block information includes call related data obtained in processing a call and used to identify the call, elements of the call, such as the call legs, and provide information for billing the call, such as billing time points. The call data block resource manager tables are illustrated in Tables 33-36.
Exemplary cdb_GetCDBData API provides procedures for retrieving call data block information from the call data block table. Table 9 provides information about the call data block APIs. The first column provides the API name. In the exemplary API shown in the eighth row of Table 9, the first column indicates the name of the API is cdb_GetCDBData. The second column of Table 9 indicates the function. With respect the exemplary API cdb_GetCDBData, the function is to get a CDB's detailed data. The third column of Table 9 provides input parameters. For the exemplary API, cdb_GetCDBData, the inputs required are the 1 Cid, which is the call identifier, and the pstCDBData, which is the address of where the CDB data should be saved. The fourth column of Table 9 provides the output of the API. For the exemplary cdb_GetCDBData API, the output is saving the CDB data at the pstCDBData address. The fifth column provides the return of the API. For the exemplary cdb_GetCDBData API, the possible returns are: CDB_SUCCESS, CDB_SHM_NOT_ATTACH, CDB_KEY_INVALID, CDB_INPUT_ADDR_INVALID. CDB_LOCK_REC_ERR, and CDB_UNLOCK_REC_ERROR.
D. Description of Other Resource Managers
Additional resource managers are described in the tables. The semaphore resource manager 612 comprises semaphore APIs and semaphore resource manager tables. In Table 1, semaphore APIs are described. Semaphore APIs provide procedures for managing semaphore variables. Semaphore variables are UNIX constructs that lock and unlock memory segments. The semaphore variables within the switch controller 112 provide controlled access to data related to ISN resources. A set of semaphore variables is created for each table for access to the resource data stored in the table. Semaphore variables act as gatekeepers for memory by preventing multiple processes from accessing a particular memory segment simultaneously. The number of processes that may access a memory segment may be adjusted by modifying a configurable variable. The value of the configurable variable establishes the threshold value of the number of processes allowed access. Two locking schemes for semaphore variables are locking of an entire table and locking of one entry within a table. The semaphore resource manager tables may be any semaphore table such as those traditionally used with UNIX platforms.
The switch controller resource manager 614 comprises switch controller APIs and switch controller resource manager tables. The switch controller resource manager APIs and switch controller resource manager tables include (1) switch controller common library APIs, (2) operational measurements area APIs and tables, and (3) heartbeat APIs and tables.
In Table 2, switch controller common library APIs are described. The switch controller common library APIs affect the switch controller common library memory segment. The switch controller common library memory segment supports shared memory used to store heartbeat information and provides an operational measurements area where processes can deposit statistical data. Switch controller common library APIs are used to create and delete the switch controller common library memory segment. In addition, switch controller common library APIs are used by routines to attach and detach from the switch controller common library memory segment.
In Table 3, operational measurements area APIs are described. Operational measurements area APIs provide procedures for managing operational measurements data. Operational measurements data includes statistics of the components of the switch controller, such as disks, central processing unit (CPU) available memory, ports, and other similar data. Tables 12-18 provide additional information describing the tables used to store operational measurements data.
In Table 4, heartbeat table APIs are described. Heartbeat table APIs provide procedures for managing heartbeat data. Heartbeat functionality is used to monitor the health of the processes within the switch controller 112. A process manager routine within the management interface function is responsible for sending heartbeat requests to other switch controller application program routines 116 within certain intervals. The recipient switch controller application program routines 116 are responsible for responding to the heartbeat requests within established intervals. Process management determines when and what action should be taken when a process is not responding in a proper manner.
Heartbeat requests and responses are conveyed by setting request and response flags through shared memory. Heartbeating through shared memory is more efficient than heartbeating by sending messages through message queues because heartbeating through shared memory reduces the message volume within the switch controller.
Use of shared memory for heartbeating is described. The shared memory segment used to perform heartbeating is referred to as the heartbeat area. In one embodiment, one of the switch controller application program routines 116 is a process manager. A process manager oversees the heartbeating function and uses a resource management API to create the heartbeat shared memory segment. Within the shared memory segment, an entry is created for each switch controller application program routine 116. The entry contains heartbeat information, such as the switch controller application program routine identifier, heartbeat interval, heartbeat state (eg. register, request, or respond), request time stamp, and unresponded time and count. Heartbeat intervals can be set to different values for different switch controller application program routines 116. Table 18 provides an exemplary table used to store heartbeat data. Table 17 illustrates an exemplary control table used to control the heartbeat table.
The process manager brings up each of the other switch controller application program routines 116. The switch controller application program routines 116 attach to the heartbeat segment. To initiate processing with a particular switch controller application program routine 116, the process manager uses a resource management API to register each switch controller application program routine's 116 heartbeat entry and establishes its heartbeating interval. The interval may be modified using another resource management API.
The process manager informs each of the switch controller application program routines 116 of the need for heartbeating by sending a message with the switch controller application program routine's 116 heartbeat handle. The process manager calls a heartbeat request API to indicate a heartbeat request. When the routine 116 receives an initial heartbeat setup message, it immediately calls a respond heartbeat API. Each time a process calls a respond API, it will get a time which tells the process when it should next call the respond API. The routines 116 can get the current set heartbeat interval time using this API as well. When switch controller application program routines 116 exit, they detach from the memory segment. During switch controller 112 shutdown, a delete heartbeat segment is called to remove the segment from the system.
Additional resource managers are described in the tables. The agent resource manager 616 comprises agent APIs and agent resource manager tables. Agent APIs include APIs to manage agent, group, and agent assignment tables. Agent table, group table, and assignment tables are stored in one shared memory segment and share the same shared memory identifier. In Table 5, agent memory segment APIs are described. Agent memory segment APIs provide procedures for managing the agent memory segment. Agent memory segment APIs are used to create and delete the agent memory segment. In addition, agent memory segment APIs are used by routines to attach and detach from the agent memory segment.
In Table 6, agent table APIs are described. Agent table APIs provide procedures for managing agent tables. Agent tables include information about agents, such as terminal identifiers, agent logon identifiers, and associated groups. After an agent establishes a connection with the switch controller and logs on, its operating state in an agent table will be updated as capable of processing calls. In addition, after the agent logs off, its operating state will be changed to unable to handle calls. An agent API is provided to find an agent within a particular group. In addition, APIs to dynamically add and delete an agent entry are also provided. Tables 20-23 illustrate tables used to store information about agents. In addition, Tables 30-32 provide tables used to store general information about agents.
In Table 7, group table APIs are described. Group table APIs provide proccdures for managing the group tables. Agents are grouped together according to their call processing functionalities. Agent group information includes information about the groups, agents assigned to the group and the number of calls queued to the group. Tables 24-26 illustrate tables used to store agent group information.
In Table 8, assignment table APIs are described. Assignment table APIs provide procedures for managing the assignment table. An agent group can have any number of agents assigned to it and an agent can be assigned to multiple groups. In order to describe the cross referencing between the agent table and group table, a separate agent assignment table is created. Tables 27-29 illustrate tables used to store agent assignment information.
The service logic program resource manager 612 comprises service logic program APIs and service logic program resource manager tables. In Table 10, service logic program APIs are described. Service logic program APIs provide procedures for managing the service logic program table. The service logic program table contains call identifier, call feature, call state and event information. The service logic program table is separate from the call data block. The service logic program table is organized on the service level. If a service logic program terminates abnormally, the service logic program can attach to this table and have access to most of the information needed about the calls in progress. Table 37 illustrates the table used to store service logic program data.
The switch resource resource manager 622 comprises switch APIs and switch resource manager tables. In Table 11, switch APIs are described. Switch APIs provide procedures for managing switch data.
Switch data includes switch matrix, card, node, span, trunk group, and other information related to the programmable switch 110 controlled by the switch controller 112. A switch matrix performs the switching functionality of interconnecting two channels, a channel from the caller and a channel to the receiver, in order to switch a call to a final destination. A card is a microprocessor chip board that is programmed to perform a specialized functionality. Cards within the programmable switch 110 are programmed with different software to perform various functions. Nodes are points of interconnection in a telecommunications network. Spans are telecommunications cables, typically fiber optic, however any medium capable of transmitting signals may used, that interconnect two components in a telecommunications network. Channels are bandwidth allocations that may be assigned to a particular call. Trunk groups are designations within software that are used for traffic routing purposes. Channels are assigned to trunk groups and a particular trunk group routes traffic between the destinations interconnected by the channels assigned. When a call is received, the destination number is used to select an appropriate trunk group and route the call via a channel assigned to the trunk group to the destination. Tables 38-59 provide additional information describing the tables used to store switch data.
While various embodiments of the present invention have been described above it should be understood that they have been presented by way of example only not limitation. Thus the breadth and scope of the present invention should not be remitted by any of the above described exemplary embodiments but should be defined only in accordance with the following claims and their equivalents.
TABLE 60 |
|
Tabman Client Table APIs |
API |
Function |
Input |
Output |
Return |
|
Add Client |
Add a NSPP client entry specified |
szClientName - client name |
|
Handle of the client or |
|
by client name and NIDS address to |
pstClient Addr - client address |
|
INVALID_HANDLE on |
|
ciient. Return the client handle. |
|
|
error |
AddUDPClient |
Add a UDP client entry specified by |
szClient Name - client name |
|
Handle of the client or |
|
client name and UDP address to |
pstClientUDPAddr - UDP |
|
INVALID_HANDLE on |
|
client. Return the client handle. |
client addr |
|
error |
DeleteClient |
Delete a client entry specified by |
hClientHandle - client handle |
|
INVALID_HANDLE - |
|
client handle |
|
|
Handle is not valid |
|
|
|
|
TRUE - client entry is deleted |
|
|
|
|
CLIENT_HAS_SERVICE - |
|
|
|
|
Client has associated service, |
|
|
|
|
needs to delete that service |
|
|
|
|
before delete this entry |
GetClientHandle |
Look for a client entry specified by |
szClientName - client name |
|
Client handle - found one |
|
client name and NIDS address. |
pstClientAddr - client addr |
|
match |
|
|
|
|
INVALID_HANDLE - no |
|
|
|
|
match |
GetUDPClientHandle |
Look for a client entry specified by |
szClientName - client name |
|
Client handle - found one |
|
client name and UDpaddress. |
pstClientUDPAddr - client |
|
match |
|
|
addr |
|
INVALID_HANDLE - no |
|
|
|
|
match |
GetClientRecord |
Copy one filed of a client's record to |
hClientHandle - client handle |
pchBuffer |
OK_CC or BAD_CC |
|
the place that pchBuffer points to. |
sOffset - offset of the field |
|
|
within the client table structure |
|
|
sSize - size of that field |
|
|
pchBuffer - buffer to copy the |
|
|
field to |
GetClientData |
Copy the whole record of one client. |
hClientHandle - client handle |
pstClTable |
OK_CC or BAD_CC |
|
|
pstClTable - buffer to copy the client |
|
|
record to |
PutClientRecord |
Update one field of a client table |
hClientHandle - client handle |
|
OK_CC or BAD_CC |
|
entry specified by client_handle. |
sOffset - offset of the field within the |
|
|
client table structure |
|
|
sSize - size of that field |
|
|
pchBuffer - buffer of client record to |
|
|
copy from |
IncClientRecord |
Increment one field of a client's |
hClientHandle - client handle |
|
OK_CC or BAD_CC |
|
record. |
sOffset - offset of the field within the |
|
|
client table structure |
|
|
sSize - size of that field |
DelClientFirstService |
Delete the client's first service entry |
RClientHandle - client handle |
|
OK_CC or BAD_CC |
|
from service table and update this |
|
client entry's service_handle field. |
GetClientCount |
Return total number of clients that |
None |
|
Number of clients connected |
|
connected to the Switch Controller. |
|
|
to switch controller |
ValidClient |
Check whether the client handle is |
hClientHandle - client handle |
|
TRUE or FALSE |
|
valid. |
LockClient |
Lock the specified client table entry |
hClientHandle - client handle |
|
TRUE or FALSE - invalid |
|
to guarantee an exciusive access to |
|
|
handle |
|
this entry. |
UnLockClient |
Unlock the specified entry to allow |
hClientHandle - client handle |
|
TRUE or FALSE - invalid |
|
other process to access to it. |
|
|
handle |
GetClientPtr |
Return the pointer to the table entry |
hClientHandle - client entry handle |
|
Pointer to the table entry |
|
specified by client_handle. |
ExternalClient |
Check whether the client is from a |
hClientHandle - client entry handle |
|
TRUE or FALSE |
|
different platform. |
ThisClientHandle |
Returns the current server handle. |
None |
|
Server handle |
BroadcastHandle |
Returns the broadcast handle. |
None |
|
Broadcast handle |
|
TABLE 61 |
|
Tabman Service Dcscriptor Table APIs |
API |
Function |
Input |
Output |
Return |
|
AddDesc |
Add a service descriptor entry to the |
uchDescType - descriptor type |
|
The new entry handle or |
|
table. |
szDescName - descriptor name |
|
INVALID_HANDLE on |
|
|
|
|
error |
DeleteDesc |
Delete a service descriptor entry. |
hDescHandle - descriptor entry handle |
|
INVALID_HANDLE - |
|
|
|
|
invalid handle |
|
|
|
|
TRUE - entry delete |
|
|
|
|
DESC_HAS_SERVICE - |
|
|
|
|
this entry still has pointer to |
|
|
|
|
service, entry not deleted |
DelDescFirstService |
Delete the first service entry in the |
hDescHandle - descriptor entry handle |
|
OK_CC or BAD_CC |
|
service table this service descriptor |
|
entry points to. |
GetDescHandle |
Look for a service descriptor entry |
szDescName - descriptor name |
|
descriptor handle or |
|
with the specified service name. |
|
|
INVALID_HANDLE - no |
|
|
|
|
match |
GetDescRecord |
Copy one field of a service |
hDescHandle - descriptor entry handle |
pchBuffer |
OK_CC or BAD_CC |
|
descriptor entry to pchBuffer. |
sOffset - offset of the field within the |
|
|
descriptor table structure |
|
|
sSize - size of that field |
|
|
pchBuffer - buffer to copy the field to |
GetDescData |
Copy the entire entry specified by |
hDescRandle - descriptor entry handle |
buf |
OK_CC or BAD_CC |
|
desc_handle to buffer pointed to by |
buf - descriptor entry record buffer |
|
buf.. |
pointer |
GetDescAutoDel |
Gets descriptor information from |
hDescHandle - descriptor entry handle |
puchSrvType, |
OK_CC or BAD_CC |
|
the Desc table. |
puchSrvType - buffer to save service |
pfAutoDel and |
|
|
type |
pQhandle |
|
|
pfAutoDel Ctree info |
|
|
pQhandle - queue handle |
PutDescRecord |
Update one field of service |
hDescflandte - descriptor entry handle |
|
OK_CC or BAD_CC |
|
descriptor table. |
sOffset - offset of the field within the |
|
|
descriptor table structure |
|
|
sSize - size of that field |
|
|
pchBuffer - buffer to copy ffie field |
|
|
from |
IncDescRecord |
Increment one field of a descriptor |
hDescHandle - descriptor handle |
|
OK_CC or BAD_CC |
|
table entry. |
sOffset - offset of the field within the |
|
|
descriptor table structure |
|
|
sSize - size of that field |
GetDescCount |
Get the service descriptor count. |
None |
|
Number of service |
|
|
|
|
descriptor entries in table |
GetDescStatus |
Check the descriptor table status. |
|
|
TRUE - changed from the |
|
|
|
|
last call |
|
|
|
|
FALSE - no change |
|
TABLE 62 |
|
Tabman Service Table |
API |
Function |
Input |
Output |
Return |
|
AddService |
Add a service table entry in service |
hClientHandle - client handle |
|
Service handle |
|
table. |
hDescHandle - descriptor table handle |
|
INVALlD_HANDLE - |
|
|
|
|
invalid handle (error) |
DeleteService |
Delete the service table entry |
hServHandle - service table handle |
|
TRUE - deleted |
|
specifled by its srvc_handle. |
|
|
INVALID_HANDLE - |
|
|
|
|
invalid handle (error) |
GetServiceRecord |
Copy one field of a service table |
hServHandle - service entry handle |
pchBuffer |
OK_CC or BAD_CC |
|
entry to pchBuffer. |
sOffset - offset of the field within the |
|
|
service table structure |
|
|
sSize - size of that field |
|
|
pchBuffer - buffer to copy the field to |
GetServiceData |
Copies an entire service record |
hServerHandle - service table handle |
pstSrvcTable, |
OK_CC or BAD_CC |
|
from the service table. Copies the |
pstsrvcTable - buffer to hold a service |
pchLocalDyn- |
|
DynShm pointed by service table to |
record |
ShmBuff |
|
dbprocess local Dyn Shm Buffer. |
pchLocalDynShmBuff - local dynamic |
|
|
share memory buffer |
|
|
usLocalDynShinBuffLen - size of the |
|
|
buffer |
|
|
hClientHandle - client handle entry |
PutServiceRecord |
Puts a service record field to the |
hServHandle - service entry handfe |
|
OK_CC or BAD_CC |
|
table. |
sOffset - offset of the field within the |
|
|
service table structure |
|
|
sSize - size of that field |
|
|
pchBuffer - buffer to copy the field |
|
|
from |
IncServiceRecord |
Increments one field of the service |
hServHandle - service entry handle |
|
OK_CC or BAD_CC |
|
record. |
sOffset - offset of the field within the |
|
|
service table structure |
|
|
sSize - size of that field |
GetServiceCount |
Get the number of service entries. |
None |
|
Service count |
|
|
|
|
BAD_CC on error |
LockService |
Lock the service entry. |
hClientUandle - client handle |
|
TRUE - locked |
|
|
hServerffandle - service handle |
|
FALSE - invalid service |
|
|
|
|
handle |
UnLockService |
Unlock the service entry. |
hClientHandle - client handle |
|
TRUE - locked |
|
|
hServerHandle - service handle |
|
FALSE - invalid service |
|
|
|
|
handle |
|
TABLE 63 |
|
Other Tabman APIs |
API |
Function |
Input |
Output |
Return |
|
CreatTable |
Used by startup process to create |
usNoOfClients max number of client |
OK_CC or BAD_CC |
|
client, service descriptor and service |
table entry |
|
tables. |
usNoOfSrvcs - max number ofservice |
|
|
table entry |
|
|
usNoOfDescs - max number of |
|
|
descriptor table entry |
AttachTable |
Attach to client, service descriptor |
|
OK_CC or BAD_CC |
|
and service tables. |
TableCleanUp |
Remove ctient, descriptor and service |
None |
None |
|
table share memory and semaphores |
|
from system. |
|
Current NIDS provides a set of |
|
semaphore operations. They are used |
|
to cooperate processes in accessing |
|
shared resources |
AttachSem |
Lock the number usNoOfSem in the |
sSemId - semaphore id of the semaphore |
None |
|
semaphore set. |
set |
|
|
usNoOfSem - offset of the semaphore |
DetachSem |
Unlock the number usNoOfSem in the |
sSemld - semaphore id of the semaphore |
None |
|
semaphore set. |
set |
|
|
usNoOfSem - offset of the semaphore |
|
TABLE 67 |
|
TABMAN CLIENT TABLE DATA STRUCTURE |
|
typedef struct ClientTableTyp |
{ |
CHAR |
achClientName[NIDS_CLIENT_NAME_LEN]; |
|
|
/* client name |
*/ |
USHORT |
usAddressFamily; |
/* NIBS address or UP address |
NIDS_ADDRESS |
stClientAddress; |
/* client address |
|
StClientUDPAddress; |
/* client UP address |
*/ |
ULONG |
ulLastReceived; |
/* last packet received time |
*/ |
SHORT |
sWDCount; |
/* unresponded watchdogs |
*/ |
USHORT |
usCurrentPacketNum; |
/* control data |
*/ |
USHORT |
usReceivedPacketNum; |
/* last received packet sequence num. |
*/ |
USHORT |
usLastSendablePacketNum; |
|
|
/* last sendable packet seq. num. |
*/ |
USHORT |
usClientsLastSendable; |
|
|
/* client last sendable packet |
*/ |
VOID |
*pstNewList; |
/* new packet Iist |
*/ |
VOID |
*pstOldList; |
/* old packet list |
*/ |
BOOL |
ProtectField; |
/* used by table handler |
*/ |
BOOL |
fClientused; |
/* Client entry used |
*/ |
USHORT |
hServiceHandle; |
/* Service Handle |
*/ |
USHORT |
hNextClientHandle; |
/* handle of next client (used element) |
*/ |
USHORT |
hPrevClientHandle; |
/* handle of Pre client (used element) |
*/ |
} ClientTableTyp; |
|
TABLE 68 |
|
TABMAN SERVICE DESCRIPTOR TABLE DATA STRUCTURE |
|
typedef struct DescTableTyp |
CHAR |
achServiceName[NIDS_SERVICE_NAME_LEN]; |
|
|
/* service name |
*/ |
UCHAR |
uchServiceType; |
/* service type flag |
*/ |
BOOL |
fDisabled; |
/* service status |
*/ |
USHORT |
usConsoles; |
/* number of clients |
*/ |
QHAND |
hQueueHandle; |
/* handle ofprocess queue |
*/ |
VOID |
*pvMessage; |
/* pointer to any message that you |
*/ |
|
|
/* may want to store |
*/ |
ULONG |
ulHostSendDiskQues; |
/* Disk queues for a particular Hostsend |
*/ |
ULONG |
ulBdrSendDiskQues; |
/* Disk queues for a particular Bdrsend |
*/ |
DescTyp |
stDesc; |
/* union of service description |
*/ |
BOOL |
ProtectField; |
/* used by table handler |
*/ |
BOOL |
fserviceDescUsed; /* Service Desc Used? |
*/ |
USHORT |
hServiceHandle; |
/* handle to service table |
*/ |
USHORT |
hNextDescHandle; |
/* next service description |
*/ |
USHORT |
hprevDescHandle; |
/* Prev service description |
*/ |
} DescTableTyp; |
|
TABLE 69 |
|
TABMAN SERVICE TABLE DATA STRUCTURE |
|
Typedef struct ServiceTableTyp |
SrvcTyp |
stSrvc; |
/* service type |
*/ |
QHAND |
hQueueHandle; |
/* handle of process queue |
*/ |
void |
pLocalRespMsg; |
/* Cail reorigination |
*/ |
BOOL |
ProtectField; |
/* used by table handler |
*/ |
BOOL |
FServiceUsed; |
/* Service Used? |
*/ |
USHORT |
hClientHandle; |
/* client handle to client table |
*/ |
USHORT |
hNextClientService; |
/* next client Service |
*/ |
USHORT |
hPrevClientService; |
*/ Prev client Service |
*/ |
USHORT |
hNextServiceHandle; |
/* forward next service |
*/ |
USHORT |
hPrevServiceHandle; |
/* backward next service |
*/ |
USHORT |
hDescHandle; |
/* Service Description Handle |
*/ |
} ServiceTableTyp; |
|
tab14.wpd |
API |
Function |
Input |
Output |
Return |
|
CreateDynamicQueue |
Create a dynamic (not predefined |
|
|
|
|
processes) queue. This procedure |
|
will use a predefined directory, a |
|
file name generated by |
|
puchServiceNamePtr to generate a |
|
unique key and use this key to |
|
generate a queue ID. |
CreateStaticQueue |
Create message queue for pre- |
sProcessNumber - process number |
actual queue id is updated |
Queue handle |
|
defined processes and associated |
(well known queue ID) |
in SYSVARs queue array |
|
them with well know pseudo |
|
identifiers. |
ReadMessageQueue |
Read message from queue and save |
sPQid - well know queue id |
usMsgType, |
OK_CC - read |
|
the message pointer to |
uMsgType - message type |
ppvMsgPointer |
message successfully |
|
ppvMsgPointer. |
lLongParm - specify what type of |
|
1 - no message if |
|
|
message should be read |
|
QUEUE_NOWAIT is |
|
|
0 - the first message on the queue |
|
specified in sNoWait |
|
|
should be returned |
|
BAD_CC - no |
|
|
>0 - the first message with a type |
|
message if otherwise |
|
|
equal to this long number should |
|
|
be returned |
|
|
<0 - the first message with the |
|
|
lowest type that is less than or |
|
|
equal to the absolute value of this |
|
|
long number |
|
|
ppvMsgPointer - message pointer |
|
|
sNoWait - blocking read or non- |
|
|
blocking read |
WriteMessageQueue |
Write a message to a queue. |
sPQid - well know queue id |
|
OK_CC or BAD_CC |
|
|
usMsgType - message type |
|
|
pmsgMsgPointer - message pointer |
RemoveMessageQueue |
Remove a queue from the system |
sPQid - well know queue ID |
|
OK_CC or BAD_CC |
|
and update the queue id array, |
|
release message memory if there |
|
are still messages in the queue. |
|
API |
Function |
Input |
Output |
Return |
|
CreateShmSystemVars |
Initially create the SYSVARS shared memory |
None |
OK_CC or BAD_CC |
|
segment and semaphore. |
AttachSysvarsSharedMem |
Attach to the SYSVARS memory segment. |
None |
OK_CC or BAD_CC |
DetachSysvarsSharedMem |
Detach from the SYSVARS memory segment. |
puchSharedAddress - attached address |
OK_CC or BAD_CC |
|
API |
Function |
Input |
Output |
Return |
|
InitDynShmPool |
Creates and initializes one dynamic shared |
usPool - SMALL or LARGE |
OK_CC or BAD_CC |
|
memory and one control segments. |
ulSegSize - segment size |
|
|
ulBlockSize - block size |
|
|
usPartitions - number of partitions in the |
|
|
segment |
|
|
ulVariableSize - the variable size partition |
|
|
size (There can be only one such partition |
|
|
segment) |
AttnDynShmPool |
Attaches to one dynamic shared memory pool. |
usPool - SMALL or LARGE |
TRUE - attached |
|
|
|
FALSE - error |
AllocDynShmPool |
Allocates blocks of memory from a dynamic |
ulSize - the size want to be allocated |
The address of the |
|
shared memory pool. |
usPool - SMALL or LARGE |
allocated |
|
|
|
block null - failed |
GetDynShmAvailPool |
Adds the available memory in each partition of |
usPool - SMALL or LARGE |
None |
|
a share memory segment and stores the result |
|
in the appropriate element of the AvailMem |
|
array in the system shared memory segment. |
FreeDynShmPool |
Frees a block of memory in the specified |
pvBlockAddr - the address of the block |
OK_CC or BAD_CC |
|
memory pool. |
usPool - SMALL or LARGE |
RemoveDynShmPool |
Removes a dynamic shared memory pool. |
usPool - SMALL or LARGE |
None |
CombDynShmPool |
Recombines contiguous idle blocks in the |
usPool - SMALL or LARGE |
OK_CC or BAD_CC |
|
partitions that aren't coagulated in the specified |
|
pool. |
|
API |
Function |
Input |
Return |
Pseudo Code |
|
Sem_Create |
Create a semaphore |
PsSem ID (where to same semaphore ID) |
φ: OK |
|
Table Sem |
set for a table. |
1Key (semaphore key) |
−1: Error |
|
|
US Max Table Entries (maximum number of |
|
|
table entries) |
|
|
1SemFlag (semget flag to indicate access right |
|
|
of semaphore) |
Sem_Init |
Initialize all the |
Semaphore ID |
0: OK |
Table Sem |
semaphores in a |
|
−1: Error |
|
semaphore set. |
Sem_Delete |
Delete a semaphore |
sSemId - (semaphore ID) |
0 - OK |
Sem |
set. |
|
−1 - on error |
Sem_Attach |
Get the semaphore |
psSemId - (where to |
0 - OK |
Sem |
ID of existing |
save the semphore ID) |
−1 - on error |
|
semaphore. |
1Key - (semaphore key) |
|
|
1 SemFlag - (semget flag to indicating access |
|
|
right of the semaphore) |
Sem_Lock |
Lock the entire |
sSemId - (semaphore ID) |
0 - OK |
Wait until [0] is 1 and decrement it by 1 to |
Table |
table. |
sSemFlag - (semaphore operation flag, like |
−1 - error |
indicate table lock request, also this will block |
|
|
SEM_UNDO) |
|
all further record locking request. Wait until |
|
|
|
|
(1) to be 0. (Wait until no record locking to this |
|
|
|
|
table.) If the last two steps are successfully |
|
|
|
|
executed, the table is in force. |
Sem_Unlock |
Unlock the entire |
sSemId - (semaphore ID) |
0 - OK |
Check to make sure [0] is 0, which means table |
Table |
table. |
sSemFlag - (semaphore operation flag, like |
−1 - error |
is locked. Increment [0] by 1 to release the |
|
|
SEM_UNDO) |
|
table lock. |
Sem_Lock |
Lock one entry of |
sSemId - semaphore ID |
0 - OK |
Wait [0] is 1 and decrement it by 1. (Wait until |
Table Entry |
the table. |
sTableEntryNo - table entry number (from 1 to |
−1 - error |
the table is not locked by others and lock it.) |
|
|
...) |
|
Increment [1] to increment the record locking |
|
|
sSemFlag - semaphore operation flag, like |
|
counter. Increment [0] by 1 to release the |
|
|
SEM_UNDO |
|
entire table lock. Last three steps are one |
|
|
|
|
atomic operation, in this way the record locking |
|
|
|
|
requirement will be executed if the record is |
|
|
|
|
not locked or queued, so entire table lock |
|
|
|
|
request will be executed after this. In this way |
|
|
|
|
we implemented first come, first serve. Wait |
|
|
|
|
[X] to be 1 and decrement it by 1. After this |
|
|
|
|
step is successfully executed, the table entry is |
|
|
|
|
locked. |
Sem_Unlock |
Unlock one entry of |
sSemId - (semaphore ID) |
0 - OK |
Increment [X] by 1 to release the record |
Table Entry |
the table. |
sTableEntryNo - (table entry no. (from 1 to |
−1 - Error |
locking. Decrement [1] to decrement the record |
|
|
....)) |
|
locking counter. These two steps should be one |
|
|
sSemFlag - (semaphore operation flag, like |
|
atomic semaphore operation |
|
|
SEM_UNDO) |
Sem_Lock |
Lock one entry of |
sSemId - semaphore ID |
0 - OK |
wait [X] to be 1 and decrement it by 1. |
Sem One |
the semaphore. |
sEntryNo - semaphore number (from 1 to ...) |
−1 - Error |
|
|
sSemFlag - (semaphore operation flag, like |
|
|
SEM_UNDO) |
Sem_Unlock |
Unlock one entry of |
sSemId - (semaphore ID) |
0 - OK |
Increment [X] by 1 to the lock. |
Sem One |
the semaphore. |
sEntryNo - (semaphore entry no. (from 1 to |
−1 - Error |
|
|
....)) |
|
|
sSemFlag - (semaphore operation flag, like |
|
|
SEM_UNDO) |
Sem_Recover |
Reset table sema- |
sSemId - semaphore ID |
0 - OK |
Get the semaphore size |
Table Sem |
phore values locked |
1Pid - process ID |
−1 - on error |
Check each record locking if it is locked, then |
|
by one process. This |
|
|
check if it was locked by this process. If YES, |
|
function is called to |
|
|
release the lock |
|
recover semaphore |
|
locking by a run |
|
away process, its |
|
previous process ID |
|
is needed. |
Sem_Get |
Get the size of |
sSemId - semaphore ID |
0 - OK |
Sem Size |
semaphore set. |
psSize - pointer to the buffer to save the size |
−1 - on error |
Sem_Get |
Get the semaphore |
sSemId - (semaphore ID) |
Output; |
Table Sem Val |
value of a table |
usTableEntryNo - (table entry index) |
pusVal - |
|
entry. |
pusVal - (pointer to the buffer to save the value) |
(semaphore |
|
|
|
value) |
|
|
|
Return: |
|
|
|
0 - OK |
|
|
|
−1 - Error |
Sem_Print |
Print all the sema- |
sSemId - semaphore ID |
Return: |
Sem |
phore values of a |
fp - output file pointer |
0 - OK |
|
semaphore set to a |
|
−1 - Error |
|
file. |
|
TABLE 2 |
|
Switch Controller Common Library Memory Segment APIs |
API |
Function |
Input |
Possible Returns |
|
CM_Create |
Creates and |
USMaxNoOf |
CM_SUCCESS |
CMSegment |
initializes the |
HBEntry - |
CM_FAIL |
|
sc_common |
maximum number |
|
shared memory |
of HB entries |
|
segment, which is |
|
composed of OM |
|
area and heartbeat |
|
table. Creates and |
|
initializes sema- |
|
phore sets for OM |
|
and HB. Pri- |
|
marily used by |
|
the process |
|
manager. |
DM_Delete |
Deletes the |
None |
CM_SUCCESS |
CMSegment |
sc_common |
|
CM_FAIL |
|
share memory |
|
segment and its |
|
semaphore sets. |
CM_Attach |
Attaches to the |
None |
CM_SUCCESS |
CMSegment |
sc_common |
|
CM_FAIL |
|
share memory |
|
segment. |
CM_Detach |
Detaches from |
None |
CM_SUCCESS |
CMSegment |
sc_common |
|
CM_FAIL |
|
segment. |
|
TABLE 3 |
|
Operational Measurements Area APIs |
API |
Function |
Input |
Return |
|
CM_SetupOMIPC |
Setup SC System shared |
None |
CM_SUCCESS |
|
memory and semaphore loop. |
|
CM_FAIL |
CM_UpdateOMIPC |
Read share memory and sema- |
None |
CM_SUCCESS |
|
phore information (ID and size |
|
CM_FAIL |
|
etc.). |
CM_PrintOMIPC |
Print IPC information to a file or |
FP - (file pointer) |
CM_SUCCESS |
|
stdout. |
|
CM_FAIL |
CM_GetOMAttr |
Returns one attribute value of |
Every attribute specification is composed of three |
CM_SUCCESS |
|
OM entry per function call. |
elements: (1) an attribute constant, (2) an attribute |
CM_SHM_NOT_ATTACH - share |
|
|
value pointer, and (3) an attribute size pointer. |
memory segment not exist |
|
|
Attribute constants are as follows: |
CM_INPUT_ADDR_INVALID |
|
|
CM_OM_ATTR_TERMINATOR (to terminate |
CM_ATTR_INVALID |
|
|
argument list) |
CM_INPUT_SIZE_INVALID |
|
|
CM_OM_ATTR_AGENT_TOTAL |
CM_OM_LOCK_AREA_ERR |
|
|
CM_OM_ATTR_AGENT_DISCONNECT |
CM_OM_UNLOCK_AREA_ERR |
|
|
CM_OM_ATTR_AGENT_CONNECT |
|
|
CM_OM_ATTR_AGENT_READY |
|
|
CM_OM_ATTR_AGENT_BUSY |
|
|
CM_OM_ATTR_CALL_QUEUED_TOTAL |
|
|
CM_OM_ATTR_PORT_TOTAL |
|
|
CM_OM_ATTR_PORT_CONFERENCE |
|
|
CM_OM_ATTR_PORT_OUT |
|
|
CM_OM_ATTR_PORT_IN |
|
|
CM_OM_ATTR_PORT_HOLD |
CM_SetOMAttr |
Set OM data fields. |
CM_ATTR_MODIFY_MODE_INC |
CM_SUCCESS |
|
|
CM_ATTR_MODIFY_MODE_DEC |
CM_SHM_NOT_ATTACH - share |
|
|
CM_ATTR_MODIFY_MODE_CLEAR |
memory segment not exist |
|
|
CM_ATTR_MODIFY_MODE_SET |
CM_INPUT_ADDR_INVALID |
|
|
|
CM_ATTR_INVALID |
|
|
|
CM_ATTR_MODIFY_MODE_INVALID |
|
|
|
CM_INPUT_SIZE_INVALID |
|
|
|
CM_OM_LOCK_AREA_ERR |
|
|
|
CM_OM_UNLOCK_AREA_ERR |
|
TABLE 4 |
|
Heartbeat Table APIs |
|
|
|
|
|
Calling |
API |
Function |
Input |
Output |
Return |
Function |
|
CM_GetTime |
Returns the time since |
None |
|
Current time |
|
|
00:00:00 GMT, |
|
January 1, 1970 |
|
measured in mini- |
|
seconds. |
CM_CreateHBTable |
Create and initialize |
usMaxNoOfHbEntry- |
|
CM_SUCCESS |
Internal |
|
heartbeat table and its |
maximum no. of entries in |
|
CM_FAIL |
API |
|
semaphore set. |
heartbeat table |
CM_DeleteHBTable |
Remove heartbeat share |
|
|
CM_SUCCESS |
Internal |
|
memory segment and its |
|
|
CM_FAIL |
API |
|
semaphore set. |
CM_AttachHBTable |
Attach to heartbeat table |
None |
|
CM_SUCCESS |
Internal |
|
segment and its |
|
|
CM_FAIL |
API |
|
semaphore set. |
CM_DetachHBTable |
Detach from heartbeat |
|
|
CM_SUCCESS |
Internal |
|
table segment and its |
|
|
CM_FAIL |
API |
|
semaphore set. |
CM_CreateHBEntry |
Create a heartbeat entry |
phHBHandle - heartbeat |
|
CM_SUCCESS |
Process |
|
in the heartbeat area. |
handle pointer |
|
CM_SHM_NOT_ATTACH - |
Manager |
|
|
1Pid - Process Id. |
|
share segment not attached |
|
|
UsInterval - heartbeat |
|
CM_HB_TABLE_FULL - |
|
|
interval for that process |
|
heartbeat table is full |
|
|
|
|
CM_FAIL - locking or unlocking |
|
|
|
|
error |
CM_DeleteHBEntry |
Delete a heartbeat entry |
hHBHandle - heartbeat |
|
CM_SUCCESS |
|
from heartbeat table. |
handle |
|
CM_SHM_NOT_ATTACH - |
|
|
|
|
share segment not attached |
|
|
|
|
CM_HB_HANDLE_INVALID - |
|
|
|
|
handle is not valid |
|
|
|
|
CM_FAIL - locking or unlocking |
|
|
|
|
error |
CM_GetHBHandle |
Returns the heartbeat |
phHBHandle - heartbeat |
|
CM_SUCCESS |
|
handle of a registered |
handle pointer |
|
CM_SHM_NOT_ATTACH - |
|
process. |
Ipid - process ID |
|
share segment not attached. |
|
|
|
|
CM_HB_KEY_INVALID - |
|
|
|
|
couldn't find heartbeat table entry |
|
|
|
|
for the process |
|
|
|
|
CM_FAIL - locking or unlocking |
|
|
|
|
error |
CM_RequestHB |
Heartbeat state will |
hHBHandle - process heart- |
if psInterval is not |
CM_SUCCESS |
Process |
|
change to request, a |
beat handle |
NULL, it will |
CM_SHM_NOT_ATTACH - |
Manager |
|
request time stamp will |
pusUnrspCount - where to |
contain the |
share segment not attached |
|
be filled in the entry. |
save unresponded count |
current interval |
CM_HB_HANDLE_INVALID - |
|
The heartbeat unrespond- |
pusInterval - interval |
psUnrspCount - |
handle is not valid |
|
ed count and time will be |
pointer (can be null) |
unresponded HB |
CM_FAIL - locking or unlocking |
|
updated by this function |
|
count |
error |
|
if needed. |
CM_RespondHB |
Indicates a heartbeat |
hHBHandle - process heart- |
if psInterval is not |
CM_SUCCESS |
Respond- |
|
respond, a respond |
beat handle |
NULL, it will |
CM_SHM_NOT_ATTACH - |
ing Pro- |
|
time stamp will be |
pdNextRspTime - where to |
contain the |
share segment not attached |
cess |
|
filled unresponded count |
save next respond time |
current interval |
CM_HB_HANDLE_INVALID - |
|
and time will be cleared. |
pusInterval - interval |
psNextRspTime - |
handle is not valid |
|
|
pointer (can be null) |
next respond time |
CM_FAIL - locking or unlocking |
|
|
|
|
error |
CM_SetHBInterval |
Set the heartbeat interval |
hHBHandle - heartbeat |
|
CM_SUCCESS |
Process |
|
in the share memory. |
handle |
|
CM_SHM_NOT_ATTACH - |
Manager |
|
|
usInterval - new heart- |
|
share segment not attached |
|
|
beat interval |
|
CM_HB_HANDLE‘3INVALID - |
|
|
|
|
handle is not valid |
|
|
|
|
CM_FAIL - other error |
CM_GetHBAttr |
Returns one attribute |
hHBHandle - to specify the |
pvAttrValue - the |
CM_SUCCESS |
|
value of heartbeat entry |
entry |
attribute value |
CM_SHM_NOT_ATTACH - |
|
per function call. |
sAttr - to specify the |
ulAttrSize - the |
share segment not attached |
|
|
attribute. |
actual attribute |
CM_HB_HANDLE_INVALID |
|
|
Possible values are: |
size |
CM_INPUT_ADDR_INVALID |
|
|
HB_ATTR_INTERVAL, |
|
CM_ATTR_INVALID |
|
|
HB_ATTR_UNRSPCOUNT, |
|
CM_INPUT_SIZE_INVALID |
|
|
HB_ATTR_UNRSPTIME |
|
|
pvAttrValue - when the |
|
|
attribute value will be returned |
|
|
ulAttrSize - size of pvAttrValue |
CM_PrintHBTable |
Print heartbeat table |
File pointer to hold the trace |
|
None |
|
summary and contents. |
info |
|
TABLE 12 |
|
Switch Controller Common Library Table |
Operational Measurements Area |
IPC Table |
(Contains information pertaining to shared memory, |
queues, and semaphores.) |
|
ch Name | IPC | 1 |
IPC 2 |
... |
IPC n |
|
I Key |
|
I Id (Identifier) |
|
I Size |
|
I Create Time |
|
|
TABLE 13 |
|
Switch Controller Common Library Table |
Operational Measurements Area |
Switch Controller CPU Availability |
Field |
CPU A |
CPU B |
... |
CPU n |
|
I Startup Time |
|
|
|
|
us Available CPU (percent) |
us Waiting CPU (percent) |
ul Total Memory |
ul Available Memory |
st Disk |
pointer to |
pointer to |
|
pointer to |
|
st Disk |
st Disk |
|
st Disk |
|
table |
table |
|
table |
|
TABLE 14 |
|
Switch Controller Common Library Table |
Operational Measurements Area |
Disk Availability |
|
ch Name | Disk | 1 |
Disk 2 |
. . . |
Disk n |
|
Total |
|
Available |
|
|
|
* 2-8 disks per CPU typical |
TABLE 15 |
|
Switch Controller Common Library |
Operational Measurements Area |
Agent Operational Measurement Counts |
|
ul Agent Total |
|
ul Agent Disconnect |
|
ul Agent Connect |
|
ul Agent Ready |
|
ul Agent Busy |
|
|
TABLE 16 |
|
Switch Controller Common Library |
Operational Measurements Area |
Switch Port Operational Measurement |
Counts |
for a Switch Controller |
|
Field |
Counts |
|
|
|
ul Port Total |
|
|
ul Port Conference |
|
ul Port Out |
|
ul Port In |
|
ul Port Hold |
|
|
TABLE 17 |
|
Switch Controller Common Library |
Control Table For Heartbeat Table |
|
Field |
Value |
Comments |
|
|
|
us Max Element |
|
max element index in the table |
|
us Use Element |
|
first element in the used list |
|
us Free Element |
|
first element in the unused list |
|
us Use Counts |
|
element count |
|
us Stand Alone |
|
table is a standalone segment flag |
|
|
TABLE 18 |
|
Switch Controller Common Library |
Heartbeat Table |
Field |
|
|
|
|
Comments |
|
I Pid | Process | 1 |
Process 2 |
. . . |
Process n |
Process |
|
|
|
|
|
Identifier |
s State |
|
|
|
|
May be |
|
|
|
|
|
register, |
|
|
|
|
|
request or |
|
|
|
|
|
respond |
us Interval |
|
|
|
|
Heartbeat |
|
|
|
|
|
interval |
us Half |
|
|
|
|
Half of the |
Interval |
|
|
|
|
heartbeat |
|
|
|
|
|
interval |
d Request |
|
|
|
|
Last request |
Time |
|
|
|
|
time stamp |
us Unrsp |
|
|
|
|
Heartbeat |
Count |
|
|
|
|
unrespond |
|
|
|
|
|
counter |
us Unrsp time |
|
|
|
|
Unresponded |
|
|
|
|
|
elapsed time |
h Prev Handle |
|
|
|
|
Previous |
|
|
|
|
|
handle |
h Next Handle |
|
|
|
|
Next handle |
ch Entry Used |
|
|
|
|
Entry used flag |
|
TABLE 19 |
|
Agent Library |
Control Table for Agent Table |
|
Field |
Value |
Comments |
|
|
|
us Max Element |
|
Max element index in the table |
|
us Use Element |
|
First element in the used list |
|
us Free Element |
|
First element in the unused list |
|
us Use Counts |
|
Element count |
|
us Stand Alone |
|
Table is a stand alone segment flag |
|
st Agent Count |
|
Agent count |
|
|
TABLE 5 |
|
Agent Memory Segment APIs |
API |
Function |
Calling Process |
Input |
Return |
|
Agt_CreateAgentSegment |
Create and initialize a stand alone share memory |
Process Manager |
usMaxClients - max no of client |
AGT_SUCCEED |
|
segment and semaphore sets for agent table, |
|
table entries (used to decide the |
AGT_FAIL |
|
group table and assignment table. |
|
size of client-agent mapping |
|
Read in table records. |
|
table size) |
Agt_DeleteAgentSegment |
Remove agent share memory segment and its |
Process Manager |
|
AGT_SUCCEED |
|
semaphore sets. |
|
|
AGT_FAIL |
Agt_AttachAgentSegment |
Attach to agent segment and its semaphore sets. |
Any process other |
|
AGT_SUCCEED |
|
|
than the Process |
|
AGT_FAIL |
|
|
Manager |
Agt_DetachAgentSegment |
Detach the agent share memory segment. |
Processes that |
|
AGT_SUCCEED |
|
|
attached before |
|
AGT_FAIL |
|
API |
Function |
Input |
Output |
Return |
|
Agt_CreateAgentEntry |
Create an entry into the |
phAgentHandle - agent handle pointer |
Search entry created in agent search table. |
AGT_SUCCESS |
|
Agent table. |
stAgentData - agent info, including TID |
|
AGT_SHM_NOT_ATTACH |
|
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_AGENT_TABLE_FULL |
Agt_DeleteAgentEntry |
Delete an agent entry |
ITid - TID of agent |
Search entry deleted. |
AGT_SUCCESS |
|
from agent table. |
|
|
AGT_SHM_NOT_ATTACH |
|
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_AGENT_KEY_INVALID |
|
|
|
|
AGT_AGENT_HAS_ASSIGNMENT |
Agt_UpdateAgentState |
Update an agent's call |
hClientHandle - client handle of the agent |
Agent s state field updated. |
AGT_SUCCESS |
|
processing state. |
ITid - TID of agent |
pchQueued - can be one of the two values: |
AGT_SHM_NOT_ATTACH |
|
|
sState - new state, can be one of the |
AGT_CALL_QUEUED_YES |
AGT_CLEINT_HANDLE_INVALID |
|
|
following values: |
AGT_CALL_QUEUED_NO |
AGT_AGENT_KEY_INVALID |
|
|
AGT_AGENT_STATE_DISCONNECT |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
AGT_AGENT_STATE_CONNECT |
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
AGT_AGENT_STATE_READY |
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
AGT_AGENT_STATE_BUSY |
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
pch Queued - if update a state to |
|
AGT_AGENT_STATE_INVALID |
|
|
READY, this field will be used to notify |
|
|
the caller whether a call is queued on |
|
|
groups that agent belongs to. |
Agt_AgentSelect |
Select an agent which is |
puchGroupNum - the group to select from |
|
AGT_SUCCESS |
|
in READY state. |
sSelectMode - mode of selection: |
|
AGT_SHM_NOT_ATTACH |
|
|
AGT_AGENT_SELECT_MODE_FIRST_ |
|
AGT_CLEINT_HANDLE_INVALID |
|
|
READY - choose first available agent |
AGT_AGENT_KEY_INVALID |
|
|
AGT_AGENT_SELECT_MODE_MOST_ |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
IDLE - choose the most idle agent |
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
phClientHandle - address to hold the |
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
agent's handle |
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
pstAgentData - address to hold the agent's |
|
AGT_NO_AGENT_AVAILABLE |
|
|
data |
|
AGT_NO_AGENT_ASSIGNED |
|
|
|
|
AGT_NO_AGENT_LOGIN |
|
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
|
AGT_AGENT_SELECT_MODE_INVALID |
|
|
|
|
AGT_INPUT_ADDRESS_NULL |
Agt_AgentDNToTid |
Agent destination number |
puchAgentDestNum - agent DN |
pITid - TID of the agent with that DN |
AGT_SUCCESS |
|
to TID conversion API. |
pITid where to save TID |
phClientHandle - client handle |
AGT_SHM_NOT_ATTACH |
|
|
phClientHandle - where to save client |
|
AGT_AGENT_DN_INVALID |
|
|
handle |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
Agt_GetAgentData |
Get an agent's detail |
(Choose either hClientHandle or ITid to |
stAgentData - returned agent data |
AGT_SUCCESS |
|
data. |
as input to identify the agent) |
|
AGT_SHM_NOT_ATTACH |
|
|
hClientHandle - client handle of agent |
|
AGT_CLIENT_HANDLE_INVALID |
|
|
ITid - TID of agent |
|
AGT_AGENT_KEY_INVALID |
|
|
stAgentData - agent data |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
|
|
|
|
AGT_INPUT_ADDR_INVALID |
Agt_SetAgentData |
Update an agent's |
(Choose either hClientHandle or 1Tid to |
agent's stAgentData field updated |
AGT_SUCCESS |
|
stAgentData field. |
as input to identify the agent) |
|
AGT_SHM-NOT-ATTACH |
|
|
hClientHandle - client handle of agent |
|
AGT_CLIENT-HANDLE_INVALID |
|
|
1Tid - TID of agent |
|
AGT_AGENT_KEY_INVALID |
|
|
stAgentData - agent data |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
|
|
|
|
AGT_INPUT_ADDR_INVALID |
Agt_GetAgentAttr |
Get only one field of |
(Choose either hClientHandle or 1Tid to |
pvAttrValue - attribute value |
AGT_SUCCESS |
|
stAgentData per function |
as input to identify the agent) |
ulAttrSize - the actual attribute size |
AGT_SHM_NOT_ATTACH |
|
call. |
hClientHandle - client handle of agent |
|
AGT_CLIENT_HANDLE_INVALID |
|
|
1Tid - TID of agent |
|
AGT_AGENT_KEY_INVALID |
|
|
sAttr - to specify attribute. Possible |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
values are. |
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
AGT_ATTR-AGENT-STATE |
|
AGT_INPUT_ADDR_INVALID |
|
|
AGT_ATTR_AGENT_DN |
|
AGT_INPUT_SIZE_INVALID |
|
|
pvAttrValue - where the attribute |
|
AGT_AGENT_ATTR_INVALID |
|
|
value will be returned |
|
|
ulAttrSize - size of pvAttrValue. |
Agt_SetAgentAttr |
Set only one field of |
(Choose either hClientHandle or 1Tid as |
PvAttrValue - the attribute value |
AGT_SUCCESS |
|
stAgentData per function |
input to identify the agent. |
|
AGT_SHM_NOT_ATTACH |
|
call. |
hClientHandle - client handle of agent |
|
AGT_CLIENT_HANDLE_INVALID |
|
|
1Tid - Tid of agent |
|
AGT_AGENT_KEY_INVALID |
|
|
sAttr - to specify attribute. Possible |
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
value are; |
|
AGT_UNLOCK_AGENT_REC_ERR |
|
|
AGT_ATTR_AGENT_STATE |
|
AGT_LOCK_AGENT_REC_ERR |
|
|
AGT_ATTR_AGENT_DN |
|
AGT_UNLOCK_AGENT_REC_ERR |
|
|
AGT_ATTR_AGENT_CATEGORY |
|
AGT_INPUT_ADDR_INVALID |
|
|
pvAttrValue - where the attribute value |
|
AGT_INPUT_SIZE_INVALID |
|
|
will be returned |
|
AGT_INVALID_AGENT_ATTR |
|
|
ulAttrSize - size of pvAttrValue. |
Agt_GetAgentHandle |
Locate an agent by its |
1Tid - TID |
|
AGT_SUCCESS |
|
TID. |
phAgentHandle - where to save agent |
|
AGT_SHM_NOT_ATTACH |
|
|
handle |
|
AGT_AGENT_KEY_INVALID |
|
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
Agt_GetAgentCounts |
Gets the number of |
pstAgentCount - address to save the agent |
|
AGT_SUCCESS |
|
agents in the agent table. |
count information |
|
AGT_SHM_NOT_ATTACH |
|
|
|
|
AGT_INPUT_ADDR_INVALID |
|
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
Agt_PrintAgentTable |
Print agent table |
fp - file pointer to hold the trace info. |
|
None |
|
summary and contents. |
Agt_PrintAgentEntry |
Print the contents of one |
(Choose either hClientHandle or 1Tid to |
|
AGT_SUCCESS |
|
agent table entry. |
as input to identify the agent) |
|
AGT_SHM_NOT_ATTACH |
|
|
hClientHandle - client handle of agent |
|
AGT_AGENT_KEY_INVALID |
|
|
1Tid - TID of agent |
|
AGT_CLIENT_HANDLE_INVALID |
Agt_PrintAgentSearchTable |
Print agent search table |
fp - file pointer to hold the trace info. |
|
None |
|
contents. |
|
API |
Function |
Input |
Output |
Return |
|
Agt_CreateGroupEntry |
Add an entry into |
phGroupHandle - group |
Search table |
AGT_SUCCESS |
|
the Group table. |
handle pointer stGroupData - |
entry is |
AGT_SHM_NOT_ATTACH |
|
|
group data including group |
created. |
AGT_LOCK_GROUP_TABLE_ERR |
|
|
number(key) |
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_TABLE_FULL |
Agt_DeleteGroupEntry |
Delete a group entry |
puchGroupNum - group |
Ssearch table |
AGT_SUCCESS |
|
from group table. |
number of the group |
entry |
AGT_SHM_NOT_ATTACH |
|
|
|
deleted. |
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
|
AGT_GROUP_HAS_ASSIGNMENT |
Agt_GetGroupHandle |
Locate a group by |
phGroupHandle - group |
|
AGT_SUCCESS |
|
its group number. |
handle pointer |
|
AGT_SHM_NOT_ATTACH |
|
|
puchGroupNum - |
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
group number |
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_KEY_INVALID |
Agt_GetGroupData |
Get an group's |
puchGroupNum - group |
|
AGT_SUCCESS |
|
detail data. |
number of the group |
|
AGT_SHM_NOT_ATTACH |
|
|
pstGroupData - group data |
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
storage pointer |
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
|
AGT_INPUT_ADDR_INVALID |
|
|
|
|
AGT_LOCK_GROUP_REC_ERR |
|
|
|
|
AGT_UNLOCK_GROUP_REC_ERR |
Agt_SetGroupData |
Update a group's |
puchGroupNum - group |
|
AGT_SUCCESS |
|
stGroupData field. |
number of the group |
|
AGT_SHM_NOT_ATTACH |
|
|
stGroupData - new group data |
|
AGT_LOCK_GROUP_TABLE _ERR |
|
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
|
AGT_INPUT_ADDR_INVALID |
|
|
|
|
AGT_LOCK_GROUP_REC_ERR |
|
|
|
|
AGT_UNLOCK_GROUP_REC_ERR |
Agt_IncreaseCallsQueuedOnGroup |
Increase number of |
puchGroupNum - group |
|
AGT_SUCCESS |
|
calls queued for a |
number |
|
AGT_SHM_NOT_ATTACH |
|
group. |
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_KEY_INVALID |
Agt_DecreaseCallsQueuedonGroup |
Decrease number of |
puchGroupNum - group |
|
AGT_SUCCESS |
|
calls queued for a |
number |
|
AGT_SHM_NOT_ATTACH |
|
group. |
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
|
AGT_GROUP_KEY_INVALID |
Agt_GetGroupCount |
Gets the number of |
pusCount - count address |
|
AGT_SUCCESS |
|
groups in the group |
|
|
AGT_SHM_NOT_ATTACH |
|
table. |
|
|
AGT_INPUT_ADDR_INVALID |
Agt_PrintGroupTable |
Print group table |
fp - file pointer to hold |
|
None |
|
summary and |
the trace info. |
|
contents. |
Agt_PrintGroupEntry |
Print the content of |
puchGroupNum - group |
|
one group |
number of the group |
|
table entry. |
fp - file pointer |
|
|
to hold the information |
Agt_PrintGroupSearchTable |
Print group search |
fp - file pointer |
|
None |
|
table contents. |
to hold the trace info. |
|
TABLE 8 |
|
Assignment Table APIs |
API |
Function |
Input |
Return |
|
Agt_CreateAssignEntry |
Add entry into |
phAssignHandle - assign handle pointer |
AGT_SUCCESS |
|
the Assign table. |
1Tid - TID of agent |
AGT_SHM_NOT_ATTACH |
|
|
uchGroupNum - group number of group |
AGT_AGENT_KEY_INVALID |
|
|
stAssignData - other assignment |
AGT_GROUP_KEY_INVALID |
|
|
related info |
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
|
|
|
AGT_ASSIGN_TABLE_FULL |
Agt_DeleteAssignEntryByKeys |
Delete an assign entry |
1Tid - TID of agent |
AGT_SUCCESS |
|
from assign table. |
puchGroupNum - group number |
AGT_SRM_NOT_ATTACH |
|
|
of group |
AGT_AGENT_KEY_INVALID |
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
Agt_DeleteAgentAssign |
Delete all of one agent's |
hClientHandle - client handle of the |
AGT_SUCCESS |
|
assignment entries. |
agent 1Tid - TID of agent |
AGT_SHM_NOT_ATTACH |
|
|
|
AGT_AGENT_KEY_INVALID |
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
Agt_DeleteGroupAssign |
Delete all of one group's |
puchGroupHandle - group number of |
AGT_SUCCESS |
|
assignment entries. |
the group |
AGT_SHM_NOT_ATTACH |
|
|
|
AGT_AGENT_KEY_INVALID |
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
Agt_GetAssignByKeys |
Locate an assignment by its |
1Tid - agent TID |
AGT_SUCCESS |
|
TID and GroupNum. |
puchGroupNum - group number |
AGT_SHM_NOT_ATTACH |
|
|
|
AGT_AGENT_KEY_INVALID |
|
|
|
AGT_GROUP_KEY_INVALID |
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_LOCK_AGENT_REC_ERR |
|
|
|
AGT_UNLOCK_AGENT_REC_ERR |
|
|
|
AGT_ASSIGN_NO_MATCH |
Agt_GetAssignCount |
Gets the number of assigns |
pusCount - total assignments |
AGT_SUCCESS |
|
in the assign table. |
|
AGT_SHM_NOT_ATTACH |
Agt_GetAgentAssignCount |
Gets the number of |
hClientHandle - client handle of an |
AGT_SUCCESS |
|
assignments for a |
agent 1Tid - TID of an agent |
AGT_SHM_NOT_ATTACH |
|
particular agent. |
pusCount - address to put count |
AGT_AGENT_KEY_INVALID |
|
|
|
AGT_CLIENT_HANDLE_INVALID |
|
|
|
AGT_LOCK_AGENT_TABLE_ERR |
|
|
|
AGT_UNLOCK_AGENT_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
Agt_GetGroupAssignCount |
Gets the number of agents |
puchGroupNum - group number of |
AGT_SUCCESS |
|
that assigned to a |
the group |
AGT_SHM_NOT_ATTACH |
|
specified group. |
pusCount where to save count |
AGT_GROUP_KEY_INVALID |
|
|
|
AGT_LOCK_GROUP_TABLE_ERR |
|
|
|
AGT_UNLOCK_GROUP_TABLE_ERR |
|
|
|
AGT_LOCK_ASSIGN_TABLE_ERR |
|
|
|
AGT_UNLOCK_ASSIGN_TABLE_ERR |
Agt_PrintAssignTable |
Print assignment table |
fp - file pointer to hold the trace info. |
None |
|
summary and contents. |
|
TABLE 20 |
|
Agent Library |
Agent Table |
|
Field |
Comments |
|
|
|
st Agent Data |
Agent data substructure |
|
h Assigned |
Assigned groups |
|
h Client Handle |
Client handle |
|
h Prev Handle |
Previous agent handle |
|
h Next Handle |
Next agent handle |
|
ch Entry Used |
Entry used flag |
|
|
|
Agent Library |
Agent Attributes Table |
Field |
|
|
|
|
Comments |
|
I Tid |
Agent |
Agent |
. . . |
Agent |
Agent terminal |
|
Tid |
1 |
Tid 2 |
|
Tid n |
identifier |
st Agent DN |
|
|
|
|
Agent |
|
|
|
|
|
destination |
|
|
|
|
|
number |
uch Agent Logon ID |
|
|
|
|
Agent logon |
|
|
|
|
|
identifier |
st Agent Attr |
|
|
|
|
Agent attribute |
|
|
|
|
|
structure |
st Last Logoff Cause |
|
|
|
|
Last logoff |
|
|
|
|
|
reason |
s State |
|
|
|
|
Agent state |
|
TABLE 22 |
|
Agent Library |
Agent Time Stamps Table |
|
Agent |
Agent |
|
Agent | |
Field |
Tid |
1 |
Tid 2 |
. . . |
Tid n |
Comments |
|
I Last Connect Time |
|
|
|
|
Last logon time |
I Last Ready Time |
|
|
|
|
Last become |
|
|
|
|
|
ready time |
I Last Busy Time |
|
|
|
|
Last become busy |
|
|
|
|
|
time |
I Last Disconnect |
|
|
|
|
Last log out time |
Time |
|
TABLE 23 |
|
Agent Library |
Agent Count Table |
|
Field |
Value |
Comments |
|
|
|
us Total |
|
Total Agent Entries |
|
us Disconnect |
|
Total Agents in Disconnect State |
|
us Connect |
|
Total Agents in Connect State |
|
us Ready |
|
Total Agents in Ready State |
|
us Busy |
|
Total Agents in Busy State |
|
|
TABLE 24 |
|
Agent Library |
Control Table for Group Table |
|
Field |
Value |
Comments |
|
|
|
us Max Element |
|
Max element index in the table |
|
us Use Element |
|
First element in the used list |
|
us Free Element |
|
First element in the unused list |
|
us Use Counts |
|
Element count |
|
us Stand Alone |
|
Table is a stand alone segment flag |
|
us Calls Queued |
|
Total number of calls queued |
|
|
TABLE 25 |
|
Agent Library |
Group Table |
Field |
|
|
|
|
Comments |
|
st Group Data |
Agent |
Agent |
. . . |
Agent |
Group information |
|
Group |
1 |
Group 2 |
|
Group n |
h Assigned |
|
|
|
|
Agents belonging to |
|
|
|
|
|
this group |
h Prev Handle |
|
|
|
|
Previous group handle |
h Next Handle |
|
|
|
|
Next group handle |
ch Entry Used |
|
|
|
|
Entry used flag |
|
TABLE 26 |
|
Agent Library |
Calls Queued Per Group |
uch Group Num |
Agent |
Agent |
... |
Agent |
Group identifier |
|
Group |
1 |
Group 2 |
|
Group n |
st Agent Count |
|
|
|
|
Number of agents in |
|
|
|
|
|
this group |
us Called Queued |
|
|
|
|
Number of calls |
|
|
|
|
|
queued in this group |
|
TABLE 27 |
|
Agent Library |
Control Assignment Table |
|
Field |
Value |
Comments |
|
|
|
us Max Element |
|
Max element index in the table |
|
us Use Element |
|
First element in the used list |
|
us Free Element |
|
First element in the unused list |
|
us Use Counts |
|
Element count |
|
us Stand Alone |
|
Table is a standalone segment |
|
|
|
flag |
|
|
TABLE 28 |
|
Agent Library |
Assignment Table |
|
Agent |
Agent |
|
|
|
|
Group |
Group | |
Agent |
Field |
|
1 |
2 |
. . . |
Group n |
Comments |
|
st Assign Data |
|
|
|
|
Assignment data field |
h Agent Prev |
|
|
|
|
Agents previous |
Handle |
|
|
|
|
assignment |
h Agent Next |
|
|
|
|
Agents next |
Handle |
|
|
|
|
assignment |
h Group Prev |
|
|
|
|
Group's previous |
Handle |
|
|
|
|
assignment |
h Group Next |
|
|
|
|
Group's next |
Handle |
|
|
|
|
assignment |
h Prev Handle |
|
|
|
|
Previous assignment |
|
|
|
|
|
handle |
h Next Handle |
|
|
|
|
Next assignment |
|
|
|
|
|
handle |
ch Entry Used |
|
|
|
|
Entry used flag |
|
TABLE 29 |
|
Agent Library |
Assignment Data Table |
Field |
|
|
|
|
Comments |
|
h Agent |
Agent |
Agent |
. . . |
Agent |
Agent table handle |
Handle |
Handle |
1 |
Handle 2 |
|
Handle n |
h Group |
|
|
|
|
Group table handle |
Handle |
|
TABLE 30 |
|
Agent Library |
Mapping Table |
Field |
|
|
|
|
Comments |
|
I Tid |
Agent |
Agent |
. . . |
Agent |
Terminal identifier |
|
Tid |
1 |
Tid 2 |
|
Tid n |
h Agent Handle |
|
|
|
|
Agent table handle |
ch Entry Used |
|
|
|
|
Entry used flag |
|
TABLE 31 |
|
Agent Library |
Fast Search for Agent Table |
Field |
|
|
|
|
Comments |
|
I Tid |
Agent |
Agent |
. . . |
Agent |
Agent terminal |
|
Tid |
1 |
Tid 2 |
|
Tid n |
identifier |
h Agent Handle |
|
|
|
|
Agent table handle |
|
TABLE 32 |
|
Agent Library |
Group Search Table |
Field |
|
|
|
|
Comments |
|
uchGroupNum |
|
|
|
|
Group Number |
h GroupHandle |
Group |
Group |
. . . |
Group |
Group Handle |
|
Handle 1 |
Handle 2 |
|
Handle n |
|
TABLE 33 |
|
Call Data Block Library |
Call Data Block Table |
Field |
|
|
|
|
Comments |
|
I Cid |
Call ID |
Call ID |
. . . |
Call ID n | Call identifier | |
|
1 |
2 |
|
|
st ANI |
|
|
|
|
Calling number |
st DN |
|
|
|
|
Called number |
st O Leg | Leg | 1 |
|
|
|
Originating leg |
st T Leg | Leg | 2 |
|
|
Leg n |
Terminating leg |
st TP |
|
|
|
|
Time points |
|
API |
Function |
Input |
Output |
Return |
|
cdb_CreateCDBTable |
Create and initialize |
usMaxNoOfCDBEntry -- maximum number of |
|
CDB_SUCCESS or CDB_FAIL |
|
a share memory |
entries in CDB table |
|
segment for CDB |
|
table. Create and |
|
initialize a semaphore |
|
set to control the |
|
access. |
cdb_DeteteCDBTable |
Delete CDB share |
None |
|
CDB_SUCCESS or CDB_FAIL |
|
memory segment and |
|
its semaphore. |
cdb_AttachCDBTable |
Attach to existing |
None |
|
CDB_SUCCESS or CDB_FAIL |
|
CDB table segment |
|
and its semaphore set. |
cdb_DetachCDBTable |
Detach from the CDB |
None |
|
CDB_SUCCESS or CDB_FAIL |
|
share memory |
|
segment. |
cdb_CreateCDBEntry |
Create a CDB table |
stCDBData -- CDB detail information |
plCid -- newly |
CDB_SUCCESS |
|
entry. |
plCid -- where the returned CID should be |
created CID |
CDB_SHM_NOT_ATTACH |
|
|
phCDBHandle -- where the returned |
phCDBHandle |
CDB_TABLE_FULL |
|
|
CDBHandle should be(can be NULL) |
newly created |
CDB_LOCK_TABLE_ERR |
|
|
|
handle |
CDB_UNLOCK_TABLE_ERR |
cdb_DeleteCDBEntry |
Delete a CDB entry. |
1Cid - call ID |
|
CDB_SUCCESS |
|
|
|
|
CDB_SHM_NOT_ATTACH |
|
|
|
|
CDB_KEY_INVALID |
|
|
|
|
CDB_LOCK_TABLE_ERR |
|
|
|
|
CDB_UNLOCK_TABLE_ERR |
cdb_SWPortToCid |
Search CID by port |
stPort - which composed of span and channel ID |
|
CDB_SUCCESS |
|
identifiers. |
plCid - where the return CID should be saved |
|
CDB_SHM_NOT_ATTACH |
|
|
|
|
CDB_PORT_INVALID |
|
|
|
|
CDB_LOCK_TABLE_ERR |
|
|
|
|
CDB_UNLOCK_TABLE_ERR |
cdb_GetCDBData |
Get an CDB's |
1Cid -- Call ID |
pstCDBData -- |
CDB_SUCCESS |
|
detail data. |
pstCDBData -- where return CDB data should |
CDB data |
CDB_SHM_NOT_ATTACH |
|
|
be saved |
|
CDB_KEY_INVALID |
|
|
|
|
CDB_INPUT_ADDR_INVALID |
|
|
|
|
CDB_LOCK_REC_ERR |
|
|
|
|
CDB_UNLOCK_REC_ERR |
cdb_SetCDBData |
Set a CDB's |
1Cid -- Call ID |
|
CDB_SUCCESS |
|
detail data. |
stCDBData -- CDB data |
|
CDB_SHM_NOT_ATTACH |
|
|
|
|
CDB_KEY_INVALID |
|
|
|
|
CDB_LOCK_REC_ERR |
|
|
|
|
CDB_UNLOCK_REC_ERR |
cdb_PrintCDBData |
Print CDB detail data. |
stCDBData -- CDB data record |
|
None |
|
|
fp -- output file pointer |
cdb_GetCDBAttr |
Returns attribute |
1Cid - Call ID |
Return attribute |
CDB_SUCCESS |
|
values |
each attribute specification is composed of three |
values and |
CDB_SHM_NOT_ATTACH |
|
|
elements: |
actual attribute |
CDB_KEY_INVALID |
|
|
attribute constants, which are of following: |
size |
CDB_INPUT_ADDR_INVALID |
|
|
CDB_ATTR_ANI |
|
CDB_INPUT_SIZE_INVALID |
|
|
CDB_ATTR_DN |
|
CDB_ATTR_INVALID |
|
|
CDB_ATTR_OLEG_PORT |
|
|
CDB_ATTR_OLEG_STATE_MACHINE_ID |
|
|
CDB_ATTR_OLEG_STATE |
|
|
CDB_ATTR_OLEG_EVENT |
|
|
CDB_ATTR_OLEG_CONF_PORT |
|
|
CDB_ATTR_TLEG_PORT |
|
|
CDB_ATTR_TLEG_STATE_MACHINE_ID |
|
|
CDB_ATTR_TLEG_STATE |
|
|
CDB_ATTR_TLEG_EVENT |
|
|
CDB_ATTR_TLEG_CONF_PORT |
|
|
CDB_ATTR_TP_1 |
|
|
CDB_ATTR_TP_4 |
|
|
CDB_ATTR_TP_5 |
|
|
CDB_ATTR_TP_6 |
|
|
CDB_ATTR_TP_7 |
|
|
attribute return value address |
|
|
size of allocated attribute return value |
|
|
Use CDB_ATTR_TERMINATOR as the last |
|
|
argument |
|
TABLE 9 |
|
API |
Function |
Input |
Output |
Return |
|
cdb_SetCDBAttr |
Sets attribute |
1Cid -- Call ID |
|
CDB_SUCCESS |
|
values. |
each attribute specification is composed of |
|
CDB_SHM_NOT_ATTACH |
|
|
four elements: |
|
CDB_KEY_INVALID |
|
|
attribute constants, which are the same as |
|
CDB_INPUT_ADDR_INVALID |
|
|
those provided above for function |
|
CDB_ATTR_INVALID |
|
|
cdb_GetCDBAttr |
|
CDB_ATTR_MODIFY_MODE_INVALID |
|
|
* attribute modify mode: |
|
CDB_LOCK_REC_ERR |
|
|
CDB_ATTR_MODIFY_MODE_CLEAR |
|
CDB_UNLOCK_REC_ERR |
|
|
CDB_ATTR_MODIFY_MODE_INC |
|
|
CDB_ATTR_MODIFY_MODE_DEC |
|
|
CDB_ATTR_MODIFY_MODE_SET |
|
|
attribute value address |
|
|
size of attribute value |
|
|
Use CDB_ATTR_TERMINATOR as |
|
|
the last argument. |
cdb_GetCDBCount |
Gets the number |
pusCount -- where the count information |
pusCount -- |
CDB_SUCCESS |
|
of CDB entries in |
should be saved |
number of |
CDB_SHM_NOT_ATTACH |
|
the table. |
|
entries |
CDB_INPUT_ADDR_INVALID |
cdb_PrintCDBTable |
Print CDB table |
fp -- output file pointer |
|
None |
|
summary and |
|
contents. |
cdb_PrintCDBEntry |
Print content of |
1Cid -- Call ID |
|
CDB_SUCCESS |
|
one CDB table |
fp -- output file pointer |
|
CDB_SHM_NOT_ATTACH |
|
entry. |
|
|
CDB_KEY_INVALID |
|
TABLE 34 |
|
Call Data Block Library |
Leg Data Table |
1 |
Leg 2 |
. . . |
Leg n |
Comments |
|
st Port |
|
|
|
|
Switch port associated with |
|
|
|
|
|
leg. |
us State Machine |
|
|
|
|
State machine identifier. |
Id |
us State |
|
|
|
|
State of leg. |
us Event |
|
|
|
|
Event occurring on leg. |
us Conf Port |
|
|
|
|
Conference port. |
|
TABLE 35 |
|
Call Data Block Library |
Port Table |
Field |
|
|
|
|
Comments |
|
s Span ID |
|
|
|
|
Span identifier |
s Channel ID |
Channel |
Channel |
. . . |
Channel | Channel identifier | |
|
1 |
2 |
|
n |
|
TABLE 36 |
|
Call Data Block Library |
Time Points |
|
Call |
Call |
|
Call | |
Field |
ID |
1 |
ID 2 |
. . . |
ID n |
Comments |
|
ul TP1 | |
|
|
|
Time point | 1 which is the time the |
|
|
|
|
|
switch controller detects an incoming |
|
|
|
|
|
call. |
ul TP4 | |
|
|
|
Time point | 4 which is the time a call |
|
|
|
|
|
is offered to an agent position. |
ul TP5 |
|
|
|
|
Time point 5 which is the time the |
|
|
|
|
|
agent port is done with a call. |
ul TP6 |
|
|
|
|
Time point 6 which is the time at |
|
|
|
|
|
which the switch controller detects |
|
|
|
|
|
answer supervision from the |
|
|
|
|
|
terminating end. |
ul TP7 |
|
|
|
|
Time point 7 which is the time at |
|
|
|
|
|
which controller detects reorigination |
|
|
|
|
|
DTMF sequence, originator |
|
|
|
|
|
disconnect, CSH timer expiration |
|
|
|
|
|
indicating terminator disconnect, or |
|
|
|
|
|
call park timer expiration (whichever |
|
|
|
|
|
occurs first). At time point 7, |
|
|
|
|
|
the switch controller may send time |
|
|
|
|
|
points to the billing system. |
|
TABLE 10 |
|
Service Logic Program Table APIs |
API |
Function |
Input |
Output |
Return |
|
slp_CreateSLPTable |
Create and initialize a |
usMaxNoOfSLPEntry -- maximum |
|
SLP_SUCCESS or SLP_FAIL |
|
share memory segment |
number of entries in SLP table |
|
for SLP table. |
slp_DeleteSLPTable |
Delete SLP share |
None |
|
SLP_SUCCESS or SLP_FAIL |
|
memory segment. |
slp_AttachSLPTable |
Attach to existing SLP |
None |
|
SLP_SUCCESS or SLP_FAIL |
|
table segment. |
slp_DetachSLPTable |
Detach from the SLP |
None |
|
SLP_SUCCESS or SLP_FAIL |
|
share memory segment. |
slp_CreateSLPEntry |
Create a SLP table entry. |
stSLPData -- SLP detail information |
phSLPHandle -- |
SLP_SUCCESS |
|
|
pbSLPHandle -- where the returned |
newly created |
SLP_SHM_NOT_ATTACH |
|
|
SLPHandle should be (can be NULL) |
handle |
SLP_TABLE_FULL |
slp_DeleteSLPEntry |
Delete a SLP entry. |
1Cid -- Call ID |
|
SLP_SUCCESS |
|
|
|
|
SLP_SHM_NOT_ATTACH |
|
|
|
|
SLP_KEY_INVALID |
slp_GetSLPData |
Get an SLP's detail data. |
1Cid -- Call ID |
pstSLPData -- |
SLP_SUCCESS |
|
|
pstSLPData -- where return SLP data |
SLP data |
SLP_SHM_NOT_ATTACH |
|
|
should be saved |
|
SLP_KEY_INVALID |
|
|
|
|
SLP_INPUT_ADDR_INVALID |
slp_SetSLPData |
Set an SLP's detail data. |
1Cid -- Call ID |
|
SLP_SUCCESS |
|
|
stSLPData -- SLP data |
|
SLP_SHM_NOT_ATTACH |
|
|
|
|
SLP_KEY_INVALID |
slp_PrintSLPData |
Print SLP detail data. |
stSLPData -- SLP data record |
|
None |
|
|
fp -- output file pointer |
slp_GetSLPAttr |
Returns attribute values. |
1Cid -- Call ID |
Return attribute |
SLP_SUCCESS |
|
|
each attribute specification is |
values and actual |
SLP_SHM_NOT_ATTACH |
|
|
composed of three elements: attribute |
attribute size |
SLP_KEY_INVALID |
|
|
constants, which are of followings: |
|
SLP_INPUT_ADDR_INVALID |
|
|
SLP_ATTR_FEATURE |
|
SLP_INPUT_SIZE_INVALID |
|
|
SLP_ATTR_FEATURE_STATE |
|
SLP_ATTR_INVALID |
|
|
SLP_ATTR_LEG_FEATURE |
|
|
SLP_ATTR_EXPECTED_EVENT |
|
|
SLP_ATTR_RELATE_CID_1 |
|
|
SLP_ATTR_RELATE_CID_2 |
|
|
SLP_ATTR_RELATE_CID_3 |
|
|
SLP_ATTR_RELATE_CID_4 |
|
|
SLP_ATTR_RELATE_CID_5 |
|
|
SLP_ATTR_RELATE_CID_6 |
|
|
SLP_ATTR_RELATE_CID_7 |
|
|
SLP_ATTR_RELATE_CID_8 |
|
|
SLP_ATTR_RELATE_CID_9 |
|
|
attribute return value address |
|
|
size of allocated attribute return value |
|
|
Use SLP_ATTR_TERMINATOR |
|
|
as the last argument |
slp_SetSLPAttr |
Sets attribute values. |
1Cid -- Call ID |
|
SLP_SUCCESS |
|
|
each attribute specification is |
|
SLP_SHM_NOT_ATTACH |
|
|
composed of four elements: attribute |
|
SLP_KEY_INVALID |
|
|
constants, which are of followings: |
|
SLP_INPUT_ADDR_INVALID |
|
|
SLP_ATTR_MODIFY_MODE_CLEAR |
|
SLP_ATTR_INVALID |
|
|
SLP_ATTR_MODIFY_MODE_INC |
|
|
SLP_ATTR_MODIFY_MODE_DEC |
|
|
SLP_ATTR_MODIFY_MODE_SET |
|
|
attribute value address |
|
|
size of attribute value |
|
|
Use SLP_ATTR_TERMINATOR |
|
|
as the last argument |
slp_GetCidByTid |
Search CID by TID. |
1Tid -- TID of agent |
|
SLP_SUCCESS |
|
|
plCid -- where return CID should be saved |
|
SLP_SHM_NOT_ATTACH |
|
|
|
|
SLP_INPUT_ADDR_INVALID |
|
|
|
|
SLP_TID_INVALID |
slp_GetSLPCount |
Gets the number of SLP |
pusCount -- where the count information |
pusCount -- |
SLP_SUCCESS |
|
entries in the table. |
should be saved |
number of entries |
SLP_SHM_NOT_ATTACH |
|
|
|
|
SLP_INPUT_ADDR_INVALID |
slp_PrintSLPTable |
Print SLP table summary |
fp -- output file pointer |
|
None |
|
and contents. |
slp_PrintSLPEntry |
Print content of one SLP |
1Cid -- Call ID |
|
SLP_SUCCESS |
|
table entry. |
fp -- output file pointer |
|
SLP_SHM_NOT_ATTACH |
|
|
|
|
SLP_KEY_INVALID |
|
TABLE 37 |
|
Service Logic Program Library |
Service Logic Program Table |
|
|
|
|
1 Cid | Call identifier | |
|
1 Tid |
Agent terminal identifier |
|
s Feature |
Feature of the call |
|
s Feature State |
State of the feature |
|
s Leg Feature |
Feature of the leg |
|
s Expected Event |
Expected event |
|
1 Relate Cid 1 |
Related Call ID 1 |
|
1 Relate Cid 2 |
Related Call ID 2 |
|
1 Relate Cid 3 |
Related Call ID 3 |
|
1 Relate Cid 4 |
Related Call ID 4 |
|
1 Relate Cid 5 |
Related Call ID 5 |
|
1 Relate Cid 6 |
Related Call ID 6 |
|
1 Relate Cid 7 |
Related Call ID 7 |
|
1 Relate Cid 8 |
Related Call ID 8 |
|
1 Relate Cid 9 |
Related Call ID 9 |
|
|
API |
Function |
Input |
Return |
|
SW_CreateSWSegment |
Create share memory segment for |
stSWSize -- define the maximum number of entries |
SW_SUCCESS |
|
switch resource tables, organize and |
for node table, conference table, span table and trunk |
SW_FAIL |
|
initialize individual tables and create |
group tables |
|
semaphores for them. |
|
Caller: PROC_MAN. |
SW_DeleteSWSegment |
Delete share memory segment for |
None |
SW_SUCCESS |
|
switch resource tables, remove |
|
SW_FAIL |
|
semaphores. |
|
Caller: PROC_MAN. |
SW_AttachSWSegment |
Attach to switch resource table share |
None |
SW_SUCCESS |
|
memory segment and semaphores. |
|
SW_FAIL |
SW_DetachSWSegment |
Detach from switch resource table |
|
SW_SUCCESS |
|
share memory. |
|
SW_FAIL |
SW_AddNode |
Add a node entry into switch node |
stNode -- contains node information, such as logical |
SW_SUCCESS |
|
table. |
node ID, node serial number etc. |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_NODE_ID_INUSE |
SW_RemoveNode |
Remove an existing node from switch |
usNodeID -- logical node ID |
SW_SUCCESS |
|
node table. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
SW_GetNodeID |
Get logical node ID by switch node |
1PhysicalID -- switch node serial number |
Output: pusNodeID -- logical node ID if function |
|
serial number. |
pusNodeID -- where to deposit the logical node ID |
returns SW SUCCESS |
|
|
|
Return: |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SUCCESS |
|
|
|
SW_KEY_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_GetNodeData |
Get node information. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
pstNodeData -- where to deposit node information |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_SetNodeData |
Set node information. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
stNodeData -- node data |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
SW_PrintNodeData |
Print node data to file. |
fp -- file pointer |
None |
|
|
stNodeData -- node data |
SW_GetNodeAttr |
Get attribute(field) values of the |
usNodeID -- logical node ID |
SW_SUCCESS |
|
specified node. |
every attribute specification is composed of three |
SW_SHM_NOT_ATTACH |
|
|
elements: |
SW_NODE_ID_INVALID |
|
|
attribute constant - specify which attribute, can be: |
SW_ATTR_INVALID |
|
|
SW_NODE_ATTR_PHYSICAL_ID |
SW_INPUT_ADDR_INVALID |
|
|
SW_NODE_ATTR_HOST_NODE_ID |
SW_INPUT_SIZE_INVALID |
|
|
SW_NODE_ATTR_SW_TYPE |
|
|
SW_NODE_ATTR_MAX_SLOT |
|
|
SW_NODE_ATTR_STATUS |
|
|
SW_NODE_ATTR_TERMINATOR (to |
|
|
terminate the argument list) |
|
|
attribute value pointer - where to deposit the |
|
|
attribute value |
|
|
attribute size pointer - the size caller allocated, |
|
|
after function call, the value is the actual size of |
|
|
the attribute value |
|
|
Note: This is a variable length argument function, |
|
|
use SW_NODE_ATTR_TERMINATOR as the last |
|
|
argument. |
SW_SetNodeAttr |
Change attribute values of the |
Similar as SW_GetNodeAttr(. . .) |
SW_SUCCESS |
|
specified node. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_ATTR_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_INPUT SIZE_INVALID |
SW_GetNodeCount |
Get number of existing switch nodes |
pusCount -- where to deposit the number of nodes |
SW_SUCCESS |
|
in the system. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_PrintNodeTable |
Print node table summary. |
fp - file pointer of the output file |
None |
SW_PrintNodeEntry |
Print one node data to an output file |
fp - file pointer |
SW_SUCCESS |
|
(or standard output). |
usNodeID - logical node ID |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
SW_GetSlotMap |
Get slot map (slot to card mapping) of |
usNodeID -- logical node ID |
Output: pusSlotMax - actual maximum number of |
|
specified node. |
pusSlotMax - number of slots caller allocates |
slots on that switch node |
|
|
pstSlots - where to deposit slot map |
Return: |
|
|
|
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_NODE_ID_INVALID |
SW_PrintSlotMap |
Print slot map to a file or standard |
fp -- file pointer |
None |
|
output. |
usSlotMax -- number of slots |
|
|
pstSlots -- slot map information |
SW_AddCard |
Add a card to a node. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot number of the card |
SW_SHM_NOT_ATTACH |
|
|
eCardType -- card type |
SW_NODE_ID_INVALID |
|
|
pvCard -- detail card structure, varies depends on |
SW_SLOT_NO_INVALID |
|
|
card type |
SW_SLOT_NO_INUSE |
|
|
|
SW_TABLE_FULL |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_RemoveCard |
Remove a card from the node. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot number of the card |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
SW_GetCard |
Get card structure (information). |
usNodeID - logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot number |
SW_SHM_NOT_ATTACH |
|
|
peCardType -- return card type |
SW_NODE_ID_INVALID |
|
|
pvCard -- return detail card structure |
SW_SLOT_NO_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
Note: declare a CardUnion variable, if card type is |
|
|
|
not known to the caller. Use the pointer to that |
|
|
|
CardUnion as pvCard argument |
SW_GetCardSlot |
Get slot no of a card by its serial |
sSerialNumber -- card serial number |
SW_SUCCESS |
|
number. |
pusNodeID -- return logical node ID |
SW_SHM_NOT_ATTACH |
|
|
pustSlotNo -- return slot no of the card |
SW_KEY_INVALID |
|
|
pstSlotData -- return general card information |
SW_INPUT_ADDR_INVALID |
SW_GetCardAttr |
Get attribute values of card. |
usNodeID -- node ID |
SW_SUCCESS |
|
|
usSlotNo - slot no |
SW_SHM_NOT_ATTACH |
|
|
sAttr -- attribute constant |
SW_NODE_ID_INVALID |
|
|
pvAttrVal - attribute value |
SW_SLOT_NO_INVALID |
|
|
|
SW_ATTR_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
SW_SetCardAttr |
Set attribute value of a card. |
usNodeID -- node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no |
SW_SHM_NOT_ATTACH |
|
|
sAttr -- attribute constant |
SW_NODE_ID_INVALID |
|
|
pvAttrVal -- attribute value |
SW_SLOT_NO_INVALID |
|
|
|
SW_ATTR_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
SW_AddStack |
Add a SS7 stack. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_NODE_ID_INVALID |
|
|
stStack -- stack info |
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_STACK_ID_INVALID |
|
|
|
SW_STACK_ID_INUSE |
SW_RemoveStack |
Remove a SS7 stack. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
usStackID -- stack ID |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_STACK_ID_INVALID |
SW_AddLinkSet |
Add a SS7 linkeset. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
stLinkeSet -- linkset info. |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_LINKSET_ID_INVALID |
|
|
|
SW_LINKSET_ID_INUSE |
SW_RemoveLinkSet |
Remove a SS7 linkeset. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
stLinksetID -- linkset ID |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_LINKSET_ID_INVALID |
SW_AddLink |
Add a link. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
stLink - link info. |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_LINK_ID_INVALID |
|
|
|
SW_LINK_ID_INUSE |
SW_RemoveLink |
Remove a link. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
usLinkID -- link ID |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_LINK_ID_INVALID |
SW_GetLink |
Get SS7 link ID of a specified |
usSpanID -- logical span ID |
SW_SUCCESS |
|
channel. |
usChannelID -- channel ID |
SW_SHM_NOT_ATTACH |
|
|
pusNodeID - return logical node ID |
SW_INPUT_ADDR_INVALID |
|
|
pusSlotNo - return slot no |
SW_KEY_INVALID |
|
|
pusLinkID - return SS7 link ID |
SW_RemoveLink2 |
Remove a SS7 link. |
usSpanID -- logical span ID |
SW_SUCCESS |
|
|
usChannelID -- channel ID |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_LINK_ID_INVALID |
SW_AddDest |
Add SS7 destination. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotID -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
stDest -- destination info. |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DEST_ID_INVALID |
|
|
|
SW_DEST_ID_INUSE |
SW_RemoveDest |
Remove a destination. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
usDestID -- destination ID |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DEST_ID_INVALID |
SW_GetDest |
Get destination ID of a specified DPC. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
ulDPC -- destination point code |
SW_NODE_ID_INVALID |
|
|
pustDestID -- return destination ID |
SW_SLOT_NO_INVALID |
|
|
|
SW_KEY_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_RemoveDest2 |
Remove destination. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
ulDPC -- destination point code |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DEST_ID_INVALID |
SW_AddRoute |
Add a SS7 route. |
usNodeID - logical node ID |
SW_SUCCESS |
|
|
usSlotNo - slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
stRoute - route info. |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_ROUTE_ID_INVALID |
|
|
|
SW_ROUTE_ID_INUSE |
SW_RemoveRoute |
Remove a SS7 route. |
usNodeID -- logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the SS7 card |
SW_SHM_NOT_ATTACH |
|
|
usRouteID -- route ID |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_ROUTE_ID_INVALID |
SW_AddSimm |
Add a simm to a MFDSP card. |
usNodeID - logical node ID |
SW_SUCCESS |
|
|
usSlotNo - slot no of the card |
SW_SHM_NOT_ATTACH |
|
|
stSimm - simm information |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_SIMM_ID_INVALID |
|
|
|
SW_SIMM_ID_INUSE |
SW_RemoveSimm |
Remove a simm from a MFDSP card. |
usNodeID - logical node ID |
SW_SUCCESS |
|
|
usSlotNo - slot no of the card |
SW_SHM_NOT_ATTACH |
|
|
usSimmID -- simm ID |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_SIMM_ID_INVALID |
SW_GetDSPResourceInfo |
Get the maximum DSP resource |
pusDSPResource - where to deposit the DSP |
SW_SUCCESS |
|
information. |
resource information |
SW_SHM_NOT_ATTACH |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_GetDChannelID |
Get an ISDN D Channel ID. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
usChannelID -- channel ID |
SW_SHM_NOT_ATTACH |
|
|
pusNodeID -- return logical node ID |
SW_INPUT_ADDR_INVALID |
|
|
pusSlotNo -- return slot no |
SW_DCHANNEL_INVALID |
|
|
pusDChannelID -- D Channel ID |
SW_AssignDChannel |
Assign an ISDN D Channel. |
usNodeID - logical node ID |
SW_SUCCESS |
|
|
usSlotNo - slot no of the card |
SW_SHM_NOT_ATTACH |
|
|
stDChannel - D Channel info. |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DCHANNEL_INUSE |
|
|
|
SW_TABLE_FULL |
SW_DeassignDChnnnel |
Remove an ISDN D Channel. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
usChannelID -- channel ID |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DCHANNEL_INVALID |
SW_AddDChannel |
Add a facility to a ISDN channel. |
usSpanID - D Channel span ID |
SW_SUCCESS |
|
|
usChannelID - D Channel Channel ID |
SW_SHM_NOT_ATTACH |
|
|
usFacSpanID - logical span ID to be added to the D |
SW_NODE_ID_INVALID |
|
|
Channel |
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DCHANNEL_INVALID |
|
|
|
SW_TABLE_FULL |
SW_RemoveDChannelFacility |
Remove a facility from an ISDN D |
usFacSpanID -- span ID to be removed from the D |
SW_SUCCESS |
|
Channel. |
Channel |
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_DCHANNEL_INVALID |
|
|
|
SW_FACILITY_INVALID |
SW_PrintCPUCard |
Print a CPU card info. |
File *fp, CPUCard stCPUCard |
SW_PrintLineCard |
Print a line card info. |
File *fp, LineCard stCard |
SW_PrintMFDSPCard |
Print MFDSP card info. |
File *fp, MFDSPCard stCard |
SW_PrintSS7Card |
Print SS7 card info. |
File *fp, SS7Card stCard |
SW_PrintEXNETCard |
Print EXNET card info. |
File *fp, EXNETCard stCard |
SW_PRINTISDNCard |
Print ISDN Card info. |
File *fp, ISDNCard st Card |
SW_PRINTOtherCard |
Print other type of card information. |
File *fp, OtherCard stCard |
SW_CreateConf |
Add a conference to conference table. |
stConfData -- conference info. |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
|
|
|
SW_TABLE_FULL |
SW_DeleteConf |
Delete a conference. |
usConfID -- conference ID |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
|
|
|
SW_CONF_ID_INVALID |
SW_ReserveConf |
Reserve a conference. |
stInput -- conference type and size in need |
SW_SUCCESS |
|
|
pstOutPut -- return conference info. |
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
|
|
|
SW_NO_CONF_AVAILABLE |
SW_ReleaseConf |
Release a previously reserved |
usConfID - conference ID |
SW_SUCCESS |
|
conference. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
|
|
|
SW_CONF_ID_INVALID |
SW_GetConfData |
Get conference data. |
usConfID -- conference ID |
SW_SUCCESS |
|
|
pstConfData -- return conference data |
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
|
|
|
SW_CONF_ID_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_SetConfData |
Change conference data. |
usConfID -- conference ID |
SW_SUCCESS |
|
|
stConfData-- conference data |
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
|
|
|
SW_CONF_ID_INVALID |
SW_PrintConfData |
Print conference data. |
fp -- output file pointer |
None |
|
|
stConfData -- conference data |
SW_GetConfCount |
Get total number of conferences in the |
pusCount - where to deposit number of conference |
SW_SUCCESS |
|
conference table. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_PrintConfTable |
Print conference table summary. |
fp -- output file pointer |
None |
SW_PrintConfEntry |
Print one conference entry. |
fp -- output file pointer |
SW_SUCCESS |
|
|
usConfID -- conference ID |
SW_SHM_NOT_ATTACH |
|
|
|
SW_CONF_ID_INVALID |
SW_PrintConfSearchTable |
Print conference search table content. |
fp -- output file pointer |
None |
SW_AssignLogicalSpan |
Assign logical span. |
usNodeID - logical node ID |
SW_SUCCESS |
|
|
usSlotNo -- slot no of the line card |
SW_SHM_NOT_ATTACH |
|
|
usPhySpanID - physical span ID on the line card |
SW_NODE_ID_INVALID |
|
|
usLogSpanID -- assigned logical span ID |
SW_SLOT_NO_INVALID |
|
|
|
SW_CARD_TYPE_INVALID |
|
|
|
SW_SPAN_ID_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_DeassignLogSpan |
De-assign one logical span. |
usLogSpanID - logical span ID |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_DeassignCardLogSpan |
De-assign all the logical spans on one |
usNodeID -- logical node ID |
SW_SUCCESS |
|
Line card. |
usSlotNo - slot no of the card |
SW_NODE_ID_INVALID |
|
|
|
SW_SLOT_NO_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_DeassignNodeLogSpan |
De-assign all the logical spans on one |
usNodeID -- logical node ID |
SW_SUCCESS |
|
node. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_NODE_ID_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_DeassignAllLogSpan |
De-assign all the logical spans. |
None |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_SpanInService |
Bring one span in service (change |
usSpanID -- logical span ID |
SW_SUCCESS |
|
span state). |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
SW_SpanOutService |
Bring one span out of service. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
SW_ChannelsInService |
Bring a range of channels in service. |
usStartSpanID -- starting logical span ID |
SW_SUCCESS |
|
|
usStartChannelID -- starting channel ID |
SW_SHM_NOT_ATTACH |
|
|
usEndSpanID -- ending logical span ID |
SW_SPAN_ID_INVALID |
|
|
usEndChannelID - ending logical channel ID |
SW_ChannelsOutService |
Bring a range of channels out of |
usStartSpanID -- starting logical span ID |
SW_SUCCESS |
|
service. |
usStartChannelID - starting channel ID |
SW_SHM_NOT_ATTACH |
|
|
usEndSpanID - ending logical span ID |
SW_SPAN_ID_INVALID |
|
|
usEndChannelID - ending logical channel ID |
SW_AddSS7CIC |
Assign SS7 CIC to channel. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
usChannelID - base channel ID |
SW_SHM_NOT_ATTACH |
|
|
ulDPC -- Destination Point Code |
SW_SPAN_ID_INVALID |
|
|
ulCIC -- base CIC |
SW_LOCK_TABLE_ERR |
|
|
usTotal -- total number of channels to be assigned |
SW_UNLOCK_TABLE_ERR |
|
|
Note: all channels should be on the same span for |
|
|
CIC assignment |
SW_RemoveSS7CIC |
De-assign SS7 CIC. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
usChannelID - channel ID |
SW_SHM_NOT_ATTACH |
|
|
usTotal -- total number of channels de-assign CIC |
SW_SPAN_ID_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_GetSS7Channel |
Get channel information by SS7 DPC |
ulDPC -- Destination Point Code |
SW_SUCCESS |
|
and CIC. |
usCIC - Circuit Identification Code |
SW_SHM_NOT_ATTACH |
|
|
pusSpanID -- return logical span ID |
SW_KEY_INVALID |
|
|
pusChannelID - return channel ID |
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_GetSpan |
Get a span structure. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
|
|
|
SW_LOCK_REC_ERR |
|
|
|
SW_UNLOCK_REC_ERR |
SW_SetSpan |
Set a span structure. |
usSpanID - logical span ID |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
|
|
|
SW_LOCK_REC_ERR |
|
|
|
SW_UNLOCK_REC_ERR |
SW_GetChannel |
Get a channel structure. |
usSpanID -- logical span ID |
SW_SUCCESS |
|
|
usChannelID - channel ID |
SW_SHM_NOT_ATTACH |
|
|
pstChannel where to deposit Channel info. |
SW_INPUT_ADDR_INVALID |
|
|
|
SW_SPAN_ID_INVALID |
|
|
|
SW_CHANNEL_ID_INVALID |
|
|
|
SW_LOCK_REC_ERR |
|
|
|
SW_UNLOCK_REC_ERR |
SW_SetChannel |
Set a channel structure. |
usSpanID -- logical span ID |
SW_SUCCESS |
|
|
usChannelID -- channel ID |
SW_SHM_NOT_ATTACH |
|
|
stChannel -- channel info |
SW_SPAN_ID_INVALID |
|
|
|
SW_CHANNEL_ID_INVALID |
|
|
|
SW_LOCK_REC_ERR |
|
|
|
SW_UNLOCK_REC_ERR |
SW_PrintSpanTable |
Print span table summary. |
fp -- output file pointer |
None |
SW_PrintSpanEntry |
Print one span info. |
fp -- output file pointer |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
SW_AddTrunkGroup |
Add one trunk group. |
stTrunkGroup -- trunk group info. |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_TABLE_FULL |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_RemoveTrunkGroup |
Remove a trunk group. |
puchTrunkGroupID -- trunk group ID |
SW_SUCCESS |
|
|
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_TRUNK_GROUP_ID_INVALID |
|
|
|
SW_DEL_SEARCH_ENTRY_ERR |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_GetTrunkGroup |
Get trunk group info. |
puchTrunkGroupID - trunk group ID |
SW_SUCCESS |
|
|
pstTrunkGroup -- return trunk group structure |
SW_SHM_NOT_ATTACH |
|
|
|
SW_TRUNK_GROUP_ID_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_SetTrunkGroup |
Change trunk group info. |
puchTrunkGroupID -- trunk group ID |
SW_SUCCESS |
|
|
stTrunkGroup - trunk group information |
SW_SHM_NOT_ATTACH |
|
|
|
SW_TRUNK_GROUP_ID_INVALID |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_EPR |
SW_GetTrunkGroupCount |
Get total number of trunk groups in |
*pusCount |
SW_SUCCESS |
|
trunk group table. |
|
SW_SHM_NOT_ATTACH |
|
|
|
SW_INPUT_ADDR_INVALID |
SW_AddChannelsToTrunkGroup |
Add a range of channels to one trunk |
puchTrunkGroupID -- trunk group ID |
SW_SUCCESS |
|
group. |
usStartSpanID - starting logical span ID |
SW_SHM_NOT_ATTACH |
|
|
usStartChannelID - starting channel ID |
SW_TRUNK_GROUP_ID_INVALID |
|
|
usEndSpanID - ending logical span ID |
SW_SPAN_ID_INVALID |
|
|
usEndChannelID - ending channel ID |
SW_INPUT_ADDR_INVALID |
|
|
Note: start → in ascending order |
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_RemoveChannelsFromTrunkGroup |
De-assign a range of channels from |
usStartSpanID -- starting logical span ID |
SW_SUCCESS |
|
their trunk groups. |
usStartChannelID - starting channel ID |
SW_SHM_NOT_ATTACH |
|
|
usEndSpanID - ending logical span ID |
SW_SPAN_ID_INVALID |
|
|
usEndChannelID -- ending channel ID |
SW_INPUT_ADDR_INVALID |
|
|
Note: start → end in ascending order |
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_ChannelSelect |
Select an available channel from a |
puchTrunkGroupID - trunk group ID |
SW_SUCCESS |
|
trunk group and reserve it. |
usSelectMode -- channel select mode, can be one |
SW_SHM_NOT_ATTACH |
|
|
of the following values: |
SW_TRUNK_GROUP_ID_INVALID |
|
|
SW_CHANNEL_SELECT_MOST_IDLE |
SW_INPUT_ADDR_INVALID |
|
|
SW_CHANNEL_SELECT_ASCENDING |
SW_LOCK_TABLE_ERR |
|
|
SW_CHANNEL_SELECT_DESCENDING |
SW_UNLOCK_TABLE_ERR |
|
|
pusSpanID -- return logical span ID |
|
|
pusChannelID -- return channel ID |
SW_ChannelRelease |
Release a channel. |
usSpanID -- logical span ID |
SW_SUCCESS |
|
|
usChannelID -- channel ID |
SW_SHM_NOT_ATTACH |
|
|
|
SW_SPAN_ID_INVALID |
|
|
|
SW_CHANNEL_ID_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_PrintTrunkGroupTable |
Print trunk group table summary. |
fp -- output file pointer |
None |
SW_PrintTrunkGroupEntry |
Print one trunk group entry. |
fp -- output file pointer |
SW_SUCCESS |
|
|
puchTrunkGroupID -- trunk group ID |
SW_SHM_NOT_ATTACH |
|
|
|
SW_INPUT_ADDR_INVALID |
|
|
|
SW_TRUNK_GROUP_ID_INVALID |
|
|
|
SW_LOCK_TABLE_ERR |
|
|
|
SW_UNLOCK_TABLE_ERR |
SW_PrintTrunkGroupSearchTable |
Print trunk group search table. |
fp -- output file pointer |
None |
|
TABLE 38 |
|
Switch Library |
Node Information Table |
Field |
|
|
|
|
Comments |
|
us Node ID | Node | 1 |
Node 2 |
. . . |
Node 3 |
Logical node |
|
|
|
|
|
identifier for the |
|
|
|
|
|
switch. |
1Physical ID |
|
|
|
|
Node serial number. |
US Host Node ID |
|
|
|
|
Host node logical |
|
|
|
|
|
identifier |
S SWType |
|
|
|
|
Switch system |
|
|
|
|
|
type (LNX, CSN) |
US MaxSlot |
|
|
|
|
Maximum number |
|
|
|
|
|
of slots. |
sStatus |
|
|
|
|
Status of the node. |
|
TABLE 39 |
|
Switch Library |
Card Information Table |
Field |
|
|
|
|
Comments |
|
usSlotNo |
|
|
|
|
stat number |
eCard Type |
|
|
|
|
card type |
Sserial Number |
Card |
Card |
. . . |
Card |
card serial number |
|
Serial |
Serial |
|
Serial |
|
No. 1 |
No. 2 |
|
No. 3 |
eCardStatus |
|
|
|
|
status of the card |
sConfigTag |
|
|
|
|
configure tag if any |
sCardRole |
|
|
|
|
primary, secondary etc. |
usMatchSlot |
|
|
|
|
matching front or rear slot |
|
TABLE 40 |
|
Switch Controller |
Slot Table |
1 |
Slot 2 |
. . . |
Slot n |
Comments |
|
stCardInfo |
|
|
|
|
generic card info |
pvCard |
|
|
|
|
specific card info |
ulCardEntrySize |
|
|
|
|
card entry size |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 41 |
|
Switch Library |
Node Table Type |
1 |
Node 2 |
. . |
Node 3 |
Comments |
|
stNodeData |
|
|
|
|
node data |
stSlotMap |
|
|
|
|
slot map |
stLineCard |
|
|
|
|
line cards |
stMFDSPCard |
|
|
|
|
MFDSP cards |
stCPUCard |
|
|
|
|
CPU cards |
stSS7Card |
|
|
|
|
SS7 cards |
stISDNCard |
|
|
|
|
ISDN cards |
stEXNETCard |
|
|
|
|
EXNET cards |
stOtherCard |
|
|
|
|
other types of card |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 42 |
|
Switch Library |
Span Map Table |
Field |
|
|
|
|
Comments |
|
usLogSpanID | Span ID | 1 |
Span ID 2 |
. . . |
Span ID 3 |
logical span ID |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 43 |
|
Switch Library |
Line Card Table |
|
Line |
Line |
|
Line | |
Field |
Card |
1 |
Card 2 |
. . . |
Card n |
Comments |
|
stCardInfo |
|
|
|
|
generic card info |
usMaxSpan |
|
|
|
|
# of spans (4, 8) |
usMaxChannel |
|
|
|
|
# of channels on |
|
|
|
|
|
each span |
stSpanMap |
|
|
|
|
physical to logical map |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 44 |
|
Switch Library |
CPU Card Table |
|
Field |
Comments |
|
|
|
stCardInfo |
generic card info |
|
chIPAddr |
Internet protocol address |
|
sConnectState |
Connect state |
|
1 SocketID |
Socket identifier |
|
chEntryUsed |
entry used flag |
|
|
TABLE 45 |
|
Switch Library |
DSP Table |
Field |
DSP1 |
DSP2 |
. . . |
DSPn |
Comments |
|
eFuncType |
|
|
|
|
function type of the DSP |
sStatus |
|
|
|
|
status of this DSP |
usMaxResource |
|
|
|
|
max resources of this type |
usCurrUsed |
|
|
|
|
current used resource |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 46 |
|
Switch Library |
Simm Table |
Field |
|
|
|
|
Comments |
|
US Simm ID |
Simm |
Simm |
. . . |
Simm |
Single inline memory |
|
ID |
1 |
ID 2 |
|
ID 3 |
module (SIMM) identifier |
eSimmType |
|
|
|
|
SIMM type |
sStatus |
|
|
|
|
status of this SIMM |
usNoDSP |
|
|
|
|
# of DSPs on this SIMM |
stDSP |
|
|
|
|
DSP structure |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 47 |
|
Switch Library |
MSDSP Card Table |
1 |
Card 2 |
. . . |
Card n |
Comments |
|
stCardInfo |
|
|
|
|
generic card info |
usNoSimm |
|
|
|
|
# of simms on the card |
stSimm |
|
|
|
|
simm card structure |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 48 |
|
Switch Library |
Stack Table |
Field |
|
|
|
|
Comments |
|
usStack ID |
Stack |
Stack |
. . . |
Stack |
stack identifier |
|
ID |
1 |
ID2 |
|
ID3 |
ulOPC |
|
|
|
|
OPC |
SS7ModVarEnum |
|
|
|
|
Message transfer part |
eMTPVariant |
SS7ModVarEnum |
|
|
|
|
Integrated Service Digital |
eISUPVariant |
|
|
|
|
Network (ISDN) User |
|
|
|
|
|
Part (ISUP) |
SS7ModVarEnum |
|
|
|
|
eL3P |
eL3PVariant |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 49 |
|
Switch Library |
Linkset Table |
Field |
|
|
|
|
Comments |
|
usLinkset ID |
Linkset |
Linkset |
. . . |
Linkset |
Linkset identifier which |
|
ID 1 |
ID 2 |
|
ID n |
should be one byte |
ulAPC |
|
|
|
|
adjacent point code |
usStackID |
|
|
|
|
stack identifier |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 50 |
|
Switch Library |
Link Table |
Field |
|
|
|
|
Comments |
|
us LinkID |
Link |
Link |
. . . |
Link |
Link identifier |
|
ID |
1 |
ID 2 |
|
ID n |
usStackID |
|
|
|
|
Stack identifier |
usLinksetID |
|
|
|
|
Linkset identifier |
usSLC |
|
|
|
|
one byte (0x00-0x0F) Signaling |
|
|
|
|
|
Link Code |
usDataRate |
|
|
|
|
one byte (0x00-64 Kbps, |
|
|
|
|
|
0x01-56 Kbps) |
usSpanID |
|
|
|
|
span ID (two bytes) |
usChannelID |
|
|
|
|
channel (one byte) |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 51 |
|
Switch Library |
Destination Table |
Field |
|
|
|
|
Comments |
|
usDestID | Dest ID | 1 |
Dest ID 2 |
. . . |
Dest |
destination identifier |
|
|
|
|
ID |
3 |
ulDPC |
|
|
|
|
destination point code |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 52 |
|
Switch Library |
Route Table |
Field |
|
|
|
|
Comments |
|
US Route ID |
Route ID |
Route ID |
. . . |
Route ID | Route identifier | |
|
1 |
2 |
|
n |
usStackID |
|
|
|
|
Stack identifier |
|
|
|
|
|
which is one byte |
|
|
|
|
|
one byte |
ulDPC |
|
|
|
|
destination point |
|
|
|
|
|
code |
usLinksetID |
|
|
|
|
Linkset identifier |
usDestID |
|
|
|
|
destination |
|
|
|
|
|
identifier |
sPriority |
|
|
|
|
priority of the |
|
|
|
|
|
route (byte) |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 53 |
|
Switch Library |
SS7 Card Table |
|
SS7 |
SS7 |
|
SS7 |
|
Field | Card | 1 |
Card 2 |
. . . |
Card n |
Comments |
|
stCardInfo |
|
|
|
|
generic card info |
stStack |
|
|
|
|
stack type |
stLinkset |
|
|
|
|
linkset type |
stLink |
|
|
|
|
link type |
stDest |
|
|
|
|
destination type |
stRoute |
|
|
|
|
route type |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 54 |
|
Switch Library |
EXNET Card Table |
|
EXNET |
EXNET |
|
EXNET |
|
Field | Card | 2 |
Card 2 |
. . . |
Card n |
Comments |
|
stCard Info |
|
|
|
|
Generic card |
|
|
|
|
|
information |
usRing ID |
|
|
|
|
Logic ring identifier |
chEntry Used |
|
|
|
|
entry used flag |
|
TABLE 55 |
|
Switch Library |
Facility Table |
Field |
|
|
|
|
Comments |
|
usFacSpan ID |
Facility |
Facility |
. . . |
Facility |
facility span |
|
Span ID 1 |
Span ID 2 |
|
Span ID n |
identifier |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 56 |
|
Switch Library |
Channel Table |
Field |
|
|
|
|
Comments |
|
usSpanID |
|
|
|
|
span identifier |
usChannelID |
Channel |
Channel |
. . . |
Channel |
channel identifier |
|
ID |
1 |
ID 2 |
|
ID n |
sFeature |
|
|
|
|
FAS or NFAS |
sRole |
|
|
|
|
primary, or |
|
|
|
|
|
secondary, |
|
|
|
|
|
independent |
usRelatedChannel |
|
|
|
|
related channel |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 57 |
|
Switch Library |
ISDN Card Table |
|
ISDN |
ISDN |
|
ISDN |
|
Field | Card | 1 |
Card 2 |
. . . |
Card n |
Comments |
|
stCardInfo |
|
|
|
|
generic card info |
usNoDChannel |
|
|
|
|
number of D channels |
stDChannel |
|
|
|
|
D channel type |
chEntryUsed |
|
|
|
|
entry used flag |
|
TABLE 58 |
|
Switch Library |
Other Card Table |
|
Field |
Comments |
|
|
|
stCardInfo |
generic card info |
|
chEntryUsed |
entry used flag |
|
|
TABLE 59 |
|
Switch Library |
Card Union Table |
|
Field |
Comments |
|
|
|
stCPUCard |
CPU card |
|
stLineCard |
Line Card |
|
stMFDSPCard |
MFDSP Card |
|
stSS7Card |
SS7 Card |
|
stISDNCard |
ISDN Card |
|
stOtherCard |
Other Card |
|
stEXNETCard |
EXNET Card |
|
|