WO2012089267A1

WO2012089267A1 - Methods, apparatuses, system, related computer program product for handling policy requests

Info

Publication number: WO2012089267A1
Application number: PCT/EP2010/070922
Authority: WO
Inventors: Sangeetha Chamaraj; Aditya Dhruva
Original assignee: Nokia Siemens Networks Oy
Current assignee: Nokia Solutions and Networks Oy
Priority date: 2010-12-30
Filing date: 2010-12-30
Publication date: 2012-07-05
Anticipated expiration: 2013-06-30

Abstract

Methods, apparatuses, system and a related computer program product for handling policy requests are disclosed. The method comprises receiving a first request for a policy engine during an establishment of a session, sending a second request based on the first policy related request to a first policy engine of a plurality of policy engines, creating a mapping between the session and the first policy engine, and storing the mapping in a first repository.

Description

DESCRIPTION

METHODS, APPARATUSES, SYSTEM, RELATED COMPUTER PROGRAM PRODUCT FOR HANDLING POLICY REQUESTS

FIELD OF THE INVENTION

The present invention relates to policy procedures in communication networks. More specifically, the present invention relates to methods, apparatuses, a system, a related computer program product for handling policy requests in communication networks.

BACKGROUND

Policy engines are used in communication networks to enforce operator defined policies as may be related to gating control, Quality of Service (QoS) control, QoS signaling etc. Examples of such policy engines are the Policy Charging and Rules Function (PCRF) in mobile networks as defined by the 3^rd generation partnership program (3GPP) , the Serving Policy Decision Function (SPDF) in fixed networks and the Packet Cable Policy Server in cable networks.

In communication networks, it is desirable that a plurality of policy engines are deployed and also the policy engines have built-in redundancy, so that in case of failure of any of the policy engines, other policy engines can handle policy related requests from network elements such as gateway elements in a communication network. When a plurality of policy engines are present in a communication network, discovery procedures for policy engines are needed to direct requests from network elements to policy engines. Such discovery procedures should also provide that requests from various network elements are directed the same policy engine throughout a session.

One solution to efficiently perform the discovery procedure is to deploy a policy request router, such as Diameter Routing Agent (DRA) defined by the 3GPP. The policy request router is a functional element that ensures that all policy related messages from various network elements in a session reach the same policy engine when multiple and separately addressable policy engines have been deployed. The policy request router maintains the policy engine routing information for a session and removes such information once the session is terminated. However, the discovery procedures using routers assume that all policy related requests are received by only one router that is able to handle the requests. In case of geographically distributed application functions and network nodes, a single router may be overloaded with policy related requests and routing the requests to the same router may not be efficient, since the location of the router may be far off from the location of the application functions and network nodes. Also, sessions may fail if there is a failure of the router. In case of multiple routers present in a communication network, policy related requests in a session may be received at different routers and each of them may handle such requests independently and route to different policy engines. This may necessitate the policy engines to retrieve data about sessions from a repository containing such data. Thus, the repository may become overloaded with such requests.

SUMMARY In consideration of the above, it is an object of examples of the present invention to overcome one or more of the above drawbacks. In particular, the present invention provides methods, apparatuses, a system, and a related computer program product for handling policy requests in communication networks .

According to a first embodiment of the present invention, there is provided a method comprising: receiving a first request for a policy engine during an establishment of a session; sending a second request based on the first request to a first policy engine of a plurality of policy engines; creating a mapping between the session and the first policy engine; and storing the mapping in a first repository.

The first policy engine may comprise a first policy engine in a sequence of a plurality of policy engines, wherein the sequence of the plurality of policy engines may be based on any of the following:

• load condition of the plurality of policy engines;

• location of the plurality of policy engines;

• a subscriber identity; and · a configuration by an operator.

The creating a mapping may be performed if a response for the second policy related request is received within a predetermined time period. The method, according to the first embodiment of the present invention may further comprise retrieving the mapping by at least one of a plurality of policy request routers.

The method, according to the first embodiment of the present invention may further comprise: sending the second policy related request to a second policy engine, if a response is not received from the first policy engine within the predetermined time; creating a mapping between the session and the second policy engine; and storing the mapping in the first repository.

The method may further comprise storing data related to the session in a second repository, wherein the data may comprise any of the following:

• a bearer identity; · radio access type;

• internet protocol connectivity access network (IP-CAN) type;

• identity of a user equipment;

• information about a serving gateway; · information about user location;

• time zone of the user; and

• identity of a destination of the session.

The first and/or second repository of the method according to the first embodiment of the present invention may comprise any of the following:

• memory of any of the plurality of policy request routers; and

• a subscriber profile repository.

The method, according to the first embodiment of the present invention, may further comprise: receiving a third request for a policy engine during a session; retrieving a mapping for the session; and sending a fourth request based on the third request to the policy engine based on the mapping for the session.

The method may further comprise: sending the fourth policy related request to another policy engine, if a response is not received from the policy engine based on the mapping within the predetermined time; updating the mapping in the first repository to map the session with the other policy engine; and storing the updated mapping in the first repository. Further, the method may comprise retrieving data related to the session from the second repository.

According to a second embodiment of the present invention, there is provided a first apparatus comprising: means for receiving a first request for a policy engine during an establishment of a session; means for transmitting a second request based on the first request to a first policy engine of a plurality of policy engines; and means for creating a mapping between the session and the first policy engine.

The first apparatus may further comprise: means for transmitting the second policy related request to a second policy engine if a response for the second policy related request is not received from the first policy engine within a predetermined time period; and means for creating a mapping between the session and the second policy engine. The first apparatus may further comprise: means for receiving a third request for a policy engine for a session; means for retrieving the mapping for the session; and means for transmitting a fourth request based on the third request to a policy engine based on the mapping for the session. The first apparatus, according to the second embodiment of the present invention may further comprise: means for transmitting the fourth request to another policy engine, if a response is not received from the policy engine based on the mapping within the predetermined time; and means for updating the mapping to map the session with the other policy engine.

The means for transmitting of the first apparatus may further be configured to transmit the mapping to a plurality of policy request routers or to a subscriber profile repository.

The second embodiment of the present invention further provides a second apparatus comprising: means for receiving a policy related request for a session; means for transmitting a response for the policy related request; and means for storing data related to the session in a repository.

The second apparatus may further comprise means for retrieving the data related to the session.

The second embodiment of the present invention also provides a third apparatus comprising: means for storing a mapping between a session and a policy engine. The third apparatus may further comprise: means for receiving a request for the mapping; and means for transmitting the mapping as response to the request.

According to a third embodiment of the present invention, there is provided a system comprising at least one of:

• a sub-system comprising at least one first apparatus of the second embodiment of the present invention;

• a sub-system comprising at least one second apparatus of the second embodiment of the present invention; a sub-system comprising at least one third apparatus the second embodiment of the present invention; and • an apparatus comprising a storage for data related to at least one of a subscriber and session.

According to a fourth embodiment of the present invention, there is provided a computer program product comprising code means for performing method steps according to first embodiment of the present invention, when run on a processing means or module.

Embodiments of the present invention may have one or more of following advantages:

• Distributed load across policy request routers because of the presence of a plurality of routers.

• All the routers are aware of the session-policy engine mapping; thus all requests during a session can be routed to the same policy engine.

• Since same policy engine handles the policy requests during a session, the need to retrieve data related to the session from a subscriber profile repository may be avoided .

• In case of a policy engine failure, an updated mapping with a new policy engine may be created that may be shared with other policy routers, thus ensuring session continuity . BRIEF DESCRIPTION OF THE DRAWINGS

Figure 1A and IB show procedures, according to an example of the present invention, for handling policy requests during an establishment of a session; Figure 2A and 2B show procedures, according to an example of the present invention, for handling policy requests during a session; Figure 3 shows procedures, according to an example of the present invention, for handling multiple policy requests during a session;

Figure 4 shows a system architecture, according to an example of the present invention, for handling policy requests; and

Figure 5 shows apparatuses, according to examples of the present invention, for handling policy requests. DETAILED DESCRIPTION OF THE PRESENT INVENTION

Examples of the present invention are described herein below by way of example with reference to the accompanying drawings .

Figure 4 shows architecture of a system according to an example of the present invention. The system may comprise:

Network nodes 41x such as gateways (e.g., Gateway General Packet Radio Service (GPRS) support node (GGSN) , Service Architecture Evolution (SAE) gateway (GW) etc) and application functions (e.g., proxy call session control function (P-CSCF) ) ;

Policy request routers 43x that may act as a policy handling front end for the network nodes, i.e., an actual policy engine may be hidden to the network nodes;

Policy engines 45x that may actually handle policy requests from the network nodes; examples of such policy engines are a Policy Charging and Rules Function (PCRF) defined by the 3GPP, a Serving Policy Decision Function (SPDF) in fixed networks and a Packet Cable Policy Server in cable networks .

One or more subscriber profile repositories (SPRs) 470 that may store subscriber data, session data and any other information that may be useful for policy evaluation by policy engines.

A network node 41x may exchange messages with a policy request router 43x over a Diameter interface. For example, a GGSN may have a Gx interface (defined by the 3GPP) with a policy request router 43x and an application function such as a P-CSCF may have a Rx interface defined by the 3GPP with the policy request router 43x. The policy request routers 43x may be interconnected with each other over Ethernet and may be deployed in a secure network. The interconnection may facilitate sharing of information between the routers. The sharing of information may be using a transport layer protocol such as user datagram protocol (UDP) dispatcher.

A policy request router 43x may exchange messages with a policy engine 45x using any transport layer protocol such as Diameter. The policy request router 43x may enhance a policy request message received from a network node 41x before sending the message to a policy engine 45x. Such an enhancement may comprise adding subscriber data to the policy request message to aid policy engine 45x in retrieving relevant session data. Additionally, the policy router 43x may specify a time period by which a response is expected and also request the policy engine 45x to report out its current load condition for load management purposes. Thus, a policy request router 43x of the present invention may be considered an enhanced Diameter routing agent. The policy engines 45x may be interconnected to each other over Ethernet and may be deployed in a secure network. They may exchange information such as session data using a transport layer protocol such as Diameter.

The subscriber profile repository (SPR) 470 can be any repository that may store subscriber data. For example, the SPR may be a home location register (HLR) , home subscriber server (HSS) or a X.500 directory database. Interface used by the policy engines 45x and policy request routers 43x depends on the repository. Examples of the interface are LDAP, Sh, SQL etc.

A policy request router 43x may receive a policy related request from network nodes such as gateways (e.g., Gateway General Packet Radio Service (GPRS) support node (GGSN) , Service Architecture Evolution (SAE) gateway (GW) etc) and application functions (e.g., proxy call session control function (P-CSCF) ) 41x. It may be noted that the network nodes may act as policy control enforcement functions (PCEF) . The policy related request may be received during either an establishment of a session or an ongoing session (e.g., X and Y in figure 4) . The policy related request may be a Diameter credit control request (CCR) message. The policy related request may have an identity of the session as well as an identity of a subscriber for which a policy evaluation may be needed. The policy request routers 43x may forward the request to a policy engine selected from a pool of policy engines 45x in the system that may be capable of performing policy evaluation and provide a response for the request based on such evaluation. The router may add additional information such as subscriber identity, request for load condition etc that may facilitate evaluation by the policy engine to form an enhanced Diameter CCR before forwarding the request. According to examples of the present invention, all policy requests for a particular session may always be handled by a selected policy engine, irrespective of which policy request router receives and forwards the requests. For example, in figure 4, policy related requests for session X may always be handled by policy engine 451, irrespective of whether policy request router 431 or 438 receives and forwards the requests. Similarly, policy related requests for session Y may always be handled by policy engine 458, irrespective of whether policy request router 431 or 438 receives and forwards the requests. This is possible since, according to examples of the present invention, a mapping may exist between a session and a policy engine. Such mapping between a session and a policy engine 45x may be created by a policy request router 43x during establishment of a session and shared with other policy request routers 43x in the system. Such sharing of the mapping may be, as already noted, using a UDP dispatcher. Alternatively, such mapping (M) may be stored in a subscriber profile repository 470. Further, the policy engines 45x may, after performing a policy evaluation during establishment of a session, store data (S) related to the session in the subscriber profile repository 470. Examples of such data related to the session are :

• an identity of a bearer;

• radio access type;

• internet protocol connectivity access network (IP-CAN) type;

· information about the user equipment initiating the session;

• information about a serving gateway such as address of the gateway;

• information about the location of the user initiating the session;

• time zone of the user; and • identity of the destination of the session.

Additionally, the data may include any time specific policies for the session and usage of resources in the session. Such data related to a session may be retrievable by the policy engines 45x when processing a policy related request for the session. The procedures by which mapping between session and policy engines may be created and stored, according to examples of the present invention, are described hereinafter with reference to figures 1A, IB, 2A, 2B and 3.

Figures 1A and IB show procedures for handling policy related requests during establishment of a session 100. A policy request router 101 may receive 110 a policy related request from a network node such as a gateway or an application function. In figure 1A, only one policy request router is shown for sake of simplicity. In a system according to examples of the present invention, a plurality of such policy request routers may be present, as described earlier. The policy request router 101 may store a sequence of a plurality of policy engines (102A, B, C, D, E, ...) . Such a sequence may be based on:

• Load conditions of the policy engines: the policy router may store a sequence on the load conditions of the policy engines at the time of handling the policy related request; for example, the policy router may choose to forward policy related requests to a policy engine that is least loaded;

• Location of the policy engines: the policy router may store a sequence based on the relative location of the policy engines with respect to its location; for example, the policy router may choose to forward policy related requests to policy engines nearer to it rather than farther from it; Identity of a subscriber initiating the session 100: for example, there may be sequence of policy engines based on subscriber identity, by which requests during a session of a subscriber of a service provider may be forwarded to policy engines deployed for the service provider; additionally, subscriber location may also be considered in handling the policy requests; for example, if a subscriber is roaming, the policy router may choose to forward the policy related request to policy engines in the visited network than the home network of the subscriber .

Configuration by an operator: a network operator may configure the sequence in the policy routers based on the current conditions of the policy engines; for example, if a policy engine failed, the operator may prefer to remove the policy engine from the sequence, so that policy requests are not forwarded to the policy engine .

The sequence of policy engines may not be static one, but may change over time, based on the network conditions. Thus a policy request router (e.g., 101) may use the sequence of policy engines at the time of receiving the policy request to choose a policy engine to forward the request to. In figure 1A, the policy request router 101 forwards 121 the policy related request to the policy engine 102A, which may be the first one in the sequence. The policy engine 102A may evaluate the request and send 131 a response to the policy request router 101. When a response is received from the policy engine 102A, the policy request router 101 may create 140A a mapping 150A. Such a mapping may map the session 100 with the policy engine 102A. The policy request router 101 may, according to examples of the present invention, store 160A the mapping 150A in a repository 103. Such a repository may be the memories of the plurality of policy request routers (similar to 101) that may be present in a system. Thus, the mapping may be available to every policy request router in the system. Thus, when a policy related request is received during a session, the policy request router may use this mapping to forward the request to the policy engine that is mapped to the session. Alternatively, the repository 103 may be a subscriber profile repository (e.g., 470 in figure 4) .

The policy engine 102A may, after processing the policy request 121 and sending the response 131 store 170 data 180 related to the session 100 in a repository 104 that may be a subscriber profile repository. According to some examples of the present invention, the repository 103 and 104 may be the same entity, storing both mapping for the session and data related to the session. According to alternative examples, the repositories 103 and 104 are different entities, with the repository 103 storing mapping for the session and the repository 104 storing data related to the session.

Figure IB shows the policy handling procedure when the policy engine 102A may not send a response (131) within a predetermined time period. In such a situation, the policy request router 101 may decide to forward 122 the request 110 to a subsequent policy engine 102B in the sequence, after the lapse of the predetermined time period. If a response is received 132 from the policy engine 102B, a mapping 150B may be created 140B between the session 100 and policy engine 102B and may be stored 160B at the repository 103. The policy engine 102B may store 170 data 180 related to the session 100 at the repository 104. It may be noted that the policy request router 101 may be programmed to forward the policy related request 110 to the subsequent policy engines 102B, C, D, E... in the sequence when a response is not received from the policy engine 102A. Such forwarding may be in succession, with a time interval between successive forwarding exceeding a predetermined time period for receiving a response. When a response is received from one of the policy engines (102B, C, D, E, ...) , a mapping of the session 100 with the policy engine is created and stored in the repository 103.

Figure 2A and 2B show handling of policy requests during an established session. In figure 2A, a policy request router 201 may receive a policy related request 210 for a session 200. The policy request router 201 may retrieve 260 a mapping 250 for the session 200 from the repository 203. Such mapping may indicate 202A as the policy engine for the session 200. The policy request router 201 may forward 221 the policy related request to the policy engine 202A. The policy engine 202A may retrieve 270 data related to the session 280 from the repository 204, before processing the request and sending a response (not shown in figure 2A) .

Figure 2B shows the policy handling procedure when a response (231) may not be received from the policy engine 202A within a predetermined time period. In this situation, the policy request router 201 may decide to forward 222 the request 210 to a subsequent policy engine 202B in the sequence, after the lapse of the predetermined time period. If a response 232 is not received from the policy engine 202B, the policy request router 201 may decide to forward 222 the request 210 to a subsequent policy engine 202C in the sequence, after the lapse of the predetermined time period. If the policy engine 202C is active, it may retrieve 270 data 280 related to the session 200 from the repository 204. The policy engine 202C may then process the request and send a response 233 to the policy request router 201. When a response is received from the policy engine 202C, the policy request router 201 may update 240U the existing mapping to create a new map 250U mapping the session 200 with the policy engine 202C and store the updated map in the repository 203.

It may be noted that the policy request router 201 may be programmed to forward the policy related request 210 to the subsequent policy engines 202B, C, D, E... in the sequence when a response is not received from the policy engine 202A. Such forwarding may be in succession, with a time interval between successive forwarding exceeding a predetermined time period for receiving a response. When a response is received from one of the policy engines (202B, C, D, E, ...) , an updated mapping of the session 200 with the policy engine may be created and stored in the repository 203.

Figure 3 shows procedures, according to examples of the present invention, for handling policy related requests 311 and 312 for two sessions 300 and 310 received at a policy router 301. The policy request router 301 may retrieve 361 a mapping 351 for the session 300 from a repository 303. Similarly, the policy request router 301 may retrieve 362 a mapping 352 for the session 310 from a repository 303. Based on the retrieved mappings 351 and 352, the policy request router 301 may forward 321, 322 the policy related requests 311 and 312 to policy engines 302A and 302B respectively.

The present invention provides a system for handling policy requests. An example of such a system is illustrated in figure 4. The system 400 may comprise:

• a sub-system 430 that may comprise a plurality of policy request routers 43x; • a sub-system 450 that may comprise a plurality of policy engines 45x;

• a sub-system 430M that may comprise a plurality of

memories 43xM present in policy request routers 43x; and · a repository 470 that may store data related to a

subscriber and/or session.

The present invention also provides apparatuses (501, 502 and 521) that may form part, respectively, of the sub-systems 430, 450 and 430M and an apparatus (504) that may provide the functions of the repository 470. Such apparatuses are illustrated in figure 5. It may be noted, according to various examples of the present invention, the apparatus 521 may be :

• part of the apparatus 501 as shown in figure 5;

· a separate entity, e.g., a repository; or

• same as repository 504, i.e., repository 504 provides the functions of 521 or 430M.

The first apparatus (PRR) 501 in accordance with the present invention may provide the functions of a policy request router such as adiameter routing agent defined by the 3GPP that may be enhanced with features of the present invention.

The first apparatus 501, according to examples of the present invention, may comprise:

· a Central Processing Unit (CPU or a core functionality)

511,

• a memory 521,

• means for receiving (Rx) 531 a policy related request during an establishment of a session; means for transmitting (Tx) 561 the policy related request; and means for creating (Cx) 551 a mapping between the session and a policy engine

The means for storing the mapping may, for example, store the mapping in the memory 521 of a plurality of apparatuses similar to 501, and may be a separate functionality or the means for transmission may perform this functionality, i.e., the means for transmission may transmit the mapping to the memory 521 of a plurality of apparatuses similar to 501 or to an external repository.

It may be noted that the means for receiving Rx 531, means for creating Cx 551 and means for transmitting 561 of the apparatus 501 may be functionalities running on the CPU 511 of the apparatus, or may alternatively be separate functional entities or means. The means for creating 551 of the apparatus 501 may be, e.g., i) a functionality residing in the means for receiving 531 of the apparatus, ii) a functionality residing in the means for transmitting 561, or ii) may be a separate functionality of the apparatus 501.

If the means for creating 551 resides in the means for transmitting 561, it may have an interface 5351 with the means for receiving 531 to obtain information about any response for a policy request that may be received by the latter. On the other hand, if the means for creating 551 resides in the means for receiving 531, it may have an interface 5561 with the means for transmitting 561 to provide a mapping between a session and a policy engine, that may be transmitted by the means for transmitting 561 to policy request routers similar to apparatus 501 or to an external repository. If the means for creating 551 is a separate functionality, it may have interfaces 5351 and 5561 with the means for receiving 531 and the means for transmitting 561 respectively to obtain information about any response received for a policy related request and to provide a mapping between a session and a policy engine to the means for transmission 561.

The CPU 511 may be configured to process various data inputs and to control the functions of the memory 521, the means for receiving 531, the means for creating 551 and the means for transmitting 561. The memory 521 may serve e.g. for storing code means for carrying out e.g. the methods according to the examples of the present invention, when run e.g. on the CPU 511. For example, the memory 521 may store mapping between a session and a policy engine. Additionally, the memory 521 may store a mapping between a session identity and a subscriber identity. The memory 521 may also store a sequence of a plurality of policy engines.

It may be noted that the means for receiving 531 and the means for transmitting 561 may alternatively be provided as integral transceivers. It may further be noted that the means for receiving 531 and the means for transmitting 561 may be implemented i) as physical transmitters/receivers for transceiving e.g. via the air interface, ii) as routing entities e.g. for sending/receiving data packets e.g. in a PS (packet switched) network, or, iii) as any suitable combination of i) and ii) .

The means for receiving 531, according to examples of the present invention, may receive messages related to policy requests for a session. Such messages may be received from a network node such as a gateway (e.g., GGSN, SAE GW) and an application function (P-CSCF) . The messages may comprise a Diameter credit control request (CCR) message at the time of establishment of a session or during an ongoing session. The means for receiving 531 may also receive responses for the policy requests from a policy engine such as a policy control and charging rules function (PCRF) . Such responses may comprise a Diameter credit control answer (CCA) message.

The means for receiving 531 of the present invention may, upon receipt of a policy related request for a session, trigger, e.g., through the interface 5361, the means for transmitting 541 to forward the policy related request to a policy engine chosen from a plurality of policy engines. The policy engine may be chosen based on a sequence of a plurality of policy engines that may be stored in the memory 521 of the apparatus 501. Alternatively, if a mapping between the session and a policy engine existing, a policy engine based on the mapping may be chosen. Such a mapping may be retrieved by the means for transmitting from the memory 521 of the apparatus 501. Alternatively, the mapping may be retrieved from a repository such as a subscriber profile repository. The means for transmitting 541 may add information such as a subscriber identity and also a request to report load condition before forwarding to the policy engine. The information such as a subscriber identity may be retrieved by the means for transmitting from the memory 521. The means for receiving 531 may, in the absence of a response for a policy related request, trigger the means for transmitting 561 to forward the policy related request to other policy engines. Further, the means for receiving 531 of the present invention may, upon receipt of a response for a policy related request from a policy engine, trigger, e.g., over the interface 5351, the means for creation 551 to create a mapping between the session and the policy engine. If a mapping is already present, the means for creation may update the mapping to map the session with the policy engine from which a response is received. The means for creation 551 may, after creation or updating of a mapping, trigger, e.g., over the interface 5561, the means for transmitting to transmit the mapping to at least one policy request router, that may provide functions similar to the apparatus 501. The mapping may be stored by the policy request routers in a memory, similar to 521.

The means for transmitting 561 may also forward the response for a policy related request to a network node such as a gateway or an application function. The second apparatus (PE) 502 in accordance with the present invention may provide a policy engine, such as a PCRF, SPDF or a packet cable policy server, enhanced with the features of the invention. The apparatus may comprise a Central Processing Unit (CPU or a core functionality) 512, a memory 522, a means for receiving Rx 532 and a means for transmitting Tx 562.

The means for receiving Rx 532 and the means for transmitting 562 of the apparatus 502 may be functionalities running on the CPU 512 of the apparatus, or may alternatively be separate functional entities or means.

The CPU 512 may be configured to process various data inputs and to control the functions of the memory 522, the means for receiving 532 and the means for transmitting 562. The memory 522 may serve e.g. for storing code means for carrying out e.g. the methods according to the examples of the present invention, when run e.g. on the CPU 512. The memory 522 may, according to examples of the present invention, store data related to a session.

It may be noted that the means for receiving 532 and the means for transmitting 562 may alternatively be provided as integral transceivers. It may further be noted that the means for receiving 532 and the means for transmitting 562 may be implemented i) as physical transmitters/receivers for transceiving e.g. via the air interface, ii) as routing entities e.g. for sending/receiving data packets e.g. in a PS (packet switched) network, or, iii) as any suitable combination of i) and ii) .

The means for receiving 532, according to examples of the present invention, may receive policy related request messages during establishment of a session or during an ongoing session. Such messages may be received from policy request router and may include a subscriber identity. The means for transmitting 562, according to the present invention, may, after a policy evaluation procedure, transmit a response for the policy related request to a policy request router. Further, the means for transmission 562 may transmit data related to the session to a repository such as a subscriber profile repository. The data related to the session may be retrieved by the means for receiving when a subsequent policy related request is received during the session .

The third apparatus (memory) 521 in accordance with the present invention may be part of the first apparatus 501. It may comprise a means for storing a mapping between a session and a policy engine. Further, it may comprise means for receiving a request for the mapping and a means for transmitting a response to the request. Such requests and response may be messages internal to the first apparatus 501. The present invention also provides a fourth apparatus 504 which may provide functions of a subscriber profile repository. The memory of the fourth apparatus may serve as a means for storing data related to a session. The fourth apparatus may further comprise means for receiving a request for data of a session and a means for transmitting a response to the request. Such requests may be received from a policy engine for evaluating a policy request. a) The present invention further relates to a computer program product. The computer program product may comprise code means for performing the procedures of policy handling described earlier with reference to figures 1, 2, and 3.

Although the present invention has been described herein before with reference to particular embodiments thereof, the present invention is not limited thereto and various modifications can be made thereto.

Claims

CLAIMS :

1. A method comprising: receiving (110) a first request for a policy engine (102) during an establishment of a session (100); sending (121) a second request based on the first request to a first policy engine (102A) of a plurality of policy engines (102); creating (140) a mapping (150A) between the session (100) and the first policy engine (102A); and storing (160A) the mapping (150A) in a first repository (103).

2. The method of claim 1, wherein the first policy

engine comprises a first policy engine in a sequence of a plurality of policy engines.

3. The method of claim 2, wherein the sequence of the plurality of policy engines (102) is based on any of the following: a) load condition of the plurality of policy engines (102) ; b) location of the plurality of policy engines

(102) ; c) subscriber identity; d) a configuration by an operator.

4. The method of claim 1, wherein the creating a mapping is performed if a response for the second policy related request is received within a predetermined time period.

5. The method of claim 1 further comprising retrieving the mapping by at least one of a plurality of policy request routers (101).

6. The method of claim 1, further comprising: sending (122) the second policy related request to a second policy engine (102B, C, D, E, ...) , if a response

(131) is not received from the first policy engine

(102A) within the predetermined time; creating (140B) a mapping (150B) between the session (100) and the second policy engine (102B); and storing (160B) the mapping (150B) in the first repository (103).

7. The method of any of preceding claims, further

comprising : storing (170) data (180) related to the session (100) in a second repository (104) .

8. The method of claim 7, wherein the data comprises any of the following: a bearer identity; radio access type; internet protocol connectivity access network (IP- CAN) type; identity of a user equipment; information about a serving gateway; information about user location; time zone of the user; and identity of a destination of the session.

The method of any of preceding claims, wherein the first (103) and/or second repository (104) comprises any of the following: a) memory of any of the plurality of policy request routers (43xM) ; and b) a subscriber profile repository (470) .

The method of any of preceding claims further comprising : receiving (210) a third request for a policy engine during a session (200); retrieving (260) a mapping (250) for the session (200); and sending (221) a fourth request based on the third request to the policy engine (202A) based on the mapping (250) for the session (200) .

The method of claim 10, further comprising: sending (222,223) the fourth policy related request to another policy engine (202B, C, D, E, ...) , if a response (231) is not received from the policy engine (202A) based on the mapping within the predetermined time ; updating (240U) the mapping (250U) in the first repository (203) to map the session (200) with the other policy engine (202C) ; and storing (260U) the updated mapping (250U) in the first repository (203) .

12. The method of claim 11, further comprising: retrieving (270) data (280) related to the session (200) from the second repository (204) .

13. An apparatus (501, 43x) comprising: means for receiving a first request for a policy engine during an establishment of a session; means for transmitting a second request based on the first request to a first policy engine of a plurality of policy engines; and means for creating a mapping between the session and the first policy engine

14. The apparatus (501, 43x) of claim 13, further

comprising: means for transmitting the second policy related request to a second policy engine if a response for the second policy related request is not received from the first policy engine within a predetermined time period; and means for creating a mapping between the session and the second policy engine.

15. The apparatus (501, 43x) of any of claims 13 and 14 further comprising: means for receiving a third request for a policy engine for a session; means for retrieving the mapping for the session; and means for transmitting a fourth request based on the third request to a policy engine based on the mapping for the session.

16. The apparatus (501, 43x) of claim 15, further

comprising: means for transmitting the fourth request to another policy engine, if a response is not received from the policy engine based on the mapping within the

predetermined time; and means for updating the mapping to map the session with the other policy engine.

17. The apparatus of claims 13-16, wherein the means for transmitting is further configured to transmit the mapping to a plurality of policy request routers.

18. The apparatus of claims 13-16, wherein the means for transmitting is further configured to transmit the mapping to a subscriber profile repository.

19. An apparatus (502, 45x) comprising: means for receiving a policy related request for a session; means for transmitting a response for the policy related request; and means for storing data related to the session in a repository .

20. The apparatus (502, 45x) of claim 19, further

comprising : means for retrieving the data related to the session.

21. An apparatus (521, 43xM) comprising: means for storing a mapping between a session and a policy engine.

22. The apparatus (521, 43xM) of claim 21, further

comprising : means for receiving a request for the mapping; and means for transmitting the mapping as response to the request .

23. A system (500, 400) comprising at least one of: a) a sub-system (430) comprising at least one apparatus (501, 43x) of any of claims 13-18; b) a sub-system (450) comprising at least one apparatus (502, 45x) of any of claims 19-20; c) a sub-system (430M) comprising at least one apparatus (521, 43xM) of any of claims 21-22; and d) an apparatus (470) comprising a storage for data related to at least one of a subscriber and session .

24. A computer program product comprising code means for performing method steps according to any of claims 1 to 12, when run on a processing means or module.