System and method for resource management

Information

  • Patent Grant
  • 7142650
  • Patent Number
    7,142,650
  • Date Filed
    Friday, June 12, 1998
    25 years ago
  • Date Issued
    Tuesday, November 28, 2006
    17 years ago
Abstract
A system and method of resource management is described. Within a telecommunications network, resources are sources of assistance in performing functions needed to process calls. The present invention is a system-wide approach to resource management that provides controlled access to information about resources. A resource management routine is described that comprises electronic libraries residing in memory of a computer system that store information about resources and resource management application programmer interfaces that are used to access the stored information.
Description
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 122a, 122b, . . . 122n 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, . . . 116n 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, . . . 122n (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 . . . 304n (304). Resource requesters 306A, 306B, 306C . . . 306n (306) obtain information about resources 310A, 310B, 310C . . . 310n (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 304n.


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 310n, the resource requester (1) 306A will access the corresponding resource manager 304, particularly resource manager (1) 304A or resource manager n 310n 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) 406a; resource manager (2) 304B includes resource manager API(s) (2) 404B and resource manager table(s) (2) 406B; and resource manager n 304n includes resource manager API(s) n 404n and resource manager table(s) n 406n. 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.















B.
Tables











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







NIDS_UDP_SOCK_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













TABLE 64







Queman APIs











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.
















TABLE 65







Sysmem APIs











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
















TABLE 66







Shmman APIs











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.
















TABLE 1







SEMAPHORE APIs











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.)









Field

















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









Field

















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










Field
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
















TABLE 6







Agent Table APIs











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.
















TABLE 7







Group Table APIs











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








Field
Comments















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



















Call Data Block APIs











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












Field
Leg 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










Field
Comments







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

















TABLE 11







Switch APIs










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












Field
Slot 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












Field
Node 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












Field
Card 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









Claims
  • 1. A computer in a telecommunications network, comprising: a processor; and a resource management means for enabling said processor to provide standardized management of multiple resources including internal operational resources, external components, and applications processing data, wherein said resource management means comprises one or more resource managers, said resource managers being one of: a semaphore resource manager; a switch controller resource manager; an agent resource manager; a call data block resource manager; a service logic resource manager; or a switch resource resource manager; wherein each of said resource managers comprises: one or more resource manager application program interfaces that manage said internal operational resources, said external components, and said applications processing data; and one or more data storing means for enabling said processor to store data in table format related to said internal operational resources, said external components, and said applications processing data, said application interfaces manipulating the data to reflect the current resource state.
  • 2. The computer of claim 1, wherein said data within said data storing means comprises one of: switch controller data; call data block data; or service logic program data.
  • 3. The computer of claim 1, wherein said resource management means further comprises: a table manager resource manager; a queue logic manager resource manager; a system manager resource manager; and a shared memory manager resource manager.
  • 4. The computer of claim 2, wherein said data comprises one or more of: switch controller IPC data; switch controller CPU availability data; switch controller disk availability data; agent operational measurement count data, wherein said agent operational measurement count data is data collected for one or more agents controlled by a switch controller; a switch port operational measurement count data, wherein said switch port operational measurement count data collected for one or more switches controlled by said switch controller; control table data for control tables within said switch controller; or heartbeat data for heartbeating of routines within said switch controller.
  • 5. The computer of claim 2, wherein said data stored in said table format comprises: call identifying information; calling number; called number; call leg information; and billing time point information.
  • 6. A computer in a telecommunications network, comprising: a processor; and plurality of application program interface means for enabling said processor which is connected to a memory, to provide an interface between one or more resource requesters and data organized in a plurality of tables, each of said plurality of tables corresponding to one of a plurality of resources, each of said plurality of application program interface means comprising: sending means for sending a query; and managing means for managing data stored in said memory and organized in table format using said query; wherein said application program interface means provides system-wide interface with said data; wherein each of said plurality of application program interface means complies with a common standard for application programmer interfaces; wherein each of said plurality of application program interface means manipulating the data to reflect the current resource state.
  • 7. The computer of claim 6, wherein said data comprises one or more of: semaphore data; switch controller data; agent data; call data block data; service logic program data; or switch data.
  • 8. The computer of claim 6, wherein one of said application programmer interface means is one of: create table semaphore; initialize table semaphore; create semaphore; initialize semaphore; delete semaphore; attach semaphore; lock semaphore table; unlock semaphore table; lock semaphore table entry; unlock semaphore table entry; lock semaphore one entry; unlock semaphore one entry; recover table semaphore; get semaphore size; get table semaphore value; or print semaphore.
  • 9. The computer of claim 6, wherein one of said application programmer interface means is one of: create switch controller common library memory segment; delete switch controller common library memory segment; attach switch controller common library memory segment; and detach switch controller common library memory segment.
  • 10. The computer of claim 6, wherein one of said application programmer interface means is one of: set up an operational measurements IPC; update an operational measurements IPC; print an operational measurements IPC; get an operational measurements attribute; or set an operational measurements attribute.
  • 11. The computer of claim 6, wherein one of said application programmer interface means is one of: get time; create a heartbeat table; delete a heartbeat table; attach to a heartbeat table; detach from a heartbeat table; create a heartbeat entry; delete a heartbeat entry; get a heartbeat handle; request heartbeat; respond heartbeat; set heartbeat interval; get heartbeat attributes; or print heartbeat table.
  • 12. The computer of claim 6, wherein one of said application programmer interface means is one of: create agent segment; delete agent segment; attach agent segment; or detach agent segment.
  • 13. The computer of claim 6, wherein one of said application programmer interface means is one of: create agent entry; delete agent entry; update agent state; agent select; agent destination number to terminal identifier conversion; get agent data; set agent data; get agent attribute; set agent attribute; get agent handle; get agent counts; print agent table; print agent entry; or print agent search table.
  • 14. The computer of claim 6, wherein one of said application programmer interface means is one of: create group entry; delete group entry; get group handle; get group data; set group data; increase calls queued on group; decrease calls queued on group; get group count; print group table; print group entry; or print group search table.
  • 15. The computer of claim 6, wherein one of said application programmer interface means is one of: create assign entry; delete assign entry by keys; delete agent assign; delete group assign; get assign by keys; get assign count; get agent assign count; get group assign count; or print assign table.
  • 16. The computer of claim 6, wherein one of said application programmer interface means is one of: create call data block table; delete call data block table; attach call data block table; detach call data block table; create call data block entry; delete call data block entry; call data block search call identifier by port identifiers; get call data block data; set call data block data; print call data block data; return call data block attribute; set call data block attribute; get number call data block entries; print call data block table; or print call data block entry.
  • 17. The computer of claim 6, wherein one of said application programmer interface means is one of: create service logic program table; delete service logic program table; attach service logic program table; detach service logic program table; create service logic program entry; delete service logic program entry; get service logic program data; set service logic program data; print service logic program data; get service logic program attribute; set service logic program attribute; service logic program search call identifier by terminal identifier; get service logic program count; print service logic program table; or print service logic program entry.
US Referenced Citations (32)
Number Name Date Kind
4928304 Sakai May 1990 A
5541917 Farris Jul 1996 A
5544163 Madonna Aug 1996 A
5640446 Everett et al. Jun 1997 A
5666486 Alfieri et al. Sep 1997 A
5673299 Fuller et al. Sep 1997 A
5684967 McKenna et al. Nov 1997 A
5706437 Kirchner et al. Jan 1998 A
5790173 Strauss et al. Aug 1998 A
5825857 Reto et al. Oct 1998 A
5826030 Hebert Oct 1998 A
5912961 Taylor et al. Jun 1999 A
5920621 Gottlieb Jul 1999 A
5937042 Sofman Aug 1999 A
1802 Ervin et al. Sep 1999 A
6058181 Hebert May 2000 A
6076114 Wesley Jun 2000 A
6088749 Hebert et al. Jul 2000 A
6097727 Peters Aug 2000 A
6108337 Sherman et al. Aug 2000 A
6119187 Hebert Sep 2000 A
1897 Fletcher et al Oct 2000 A
6134618 Hebert Oct 2000 A
6188761 Dickerman et al. Feb 2001 B1
6421737 Stone et al. Jul 2002 B1
6510164 Ramaswamy et al. Jan 2003 B1
20010016038 Sammon et al. Aug 2001 A1
20010052006 Barker et al. Dec 2001 A1
20020120741 Webb et al. Aug 2002 A1
20020152305 Jackson et al. Oct 2002 A1
20020194251 Richter et al. Dec 2002 A1
20030046396 Richter et al. Mar 2003 A1