diff --git a/callcontrol/rating.py b/callcontrol/rating.py
index 31ec5b2..57fe65d 100644
--- a/callcontrol/rating.py
+++ b/callcontrol/rating.py
@@ -1,331 +1,333 @@
 # Copyright (C) 2005-2010 AG Projects. See LICENSE for details.
 #
 
 """Rating engine interface implementation."""
 
 import random
 import socket
 from collections import deque
 
 from application.configuration import ConfigSection, ConfigSetting
 from application.configuration.datatypes import EndpointAddress
 from application.system import host
 from application import log
 from application.python.types import Singleton
 
 from twisted.internet.protocol import ReconnectingClientFactory
 from twisted.internet.error import TimeoutError
 from twisted.internet import reactor, defer
 from twisted.protocols.basic import LineOnlyReceiver
 from twisted.python import failure
 
 from callcontrol import configuration_filename
 
 ##
 ## Rating engine configuration
 ##
 class RatingEngineAddress(EndpointAddress):
     default_port = 9024
     name = 'rating engine address'
 
 class RatingEngineAddresses(list):
     def __new__(cls, engines):
         engines = engines.split()
         engines = [RatingEngineAddress(engine) for engine in engines]
         return engines
 
 class TimeLimit(int):
     """A positive time limit (in seconds) or None"""
     def __new__(typ, value):
         if value.lower() == 'none':
             return None
         try:
             limit = int(value)
         except:
             raise ValueError("invalid time limit value: %r" % value)
         if limit < 0:
             raise ValueError("invalid time limit value: %r. should be positive." % value)
         return limit
 
 class RatingConfig(ConfigSection):
     __cfgfile__ = configuration_filename
     __section__ = 'CDRTool'
     address = ConfigSetting(type=RatingEngineAddresses, value=[])
     timeout = 500
 
 class CallControlConfig(ConfigSection):
     __cfgfile__ = configuration_filename
     __section__ = 'CallControl'
     prepaid_limit = ConfigSetting(type=TimeLimit, value=None)
     limit = ConfigSetting(type=TimeLimit, value=None)
 
 if not RatingConfig.address:
     try:
         RatingConfig.address = RatingEngineAddresses('cdrtool.' + socket.gethostbyaddr(host.default_ip)[0].split('.', 1)[1])
     except Exception, e:
         log.fatal('Cannot resolve hostname %s' % ('cdrtool.' + socket.gethostbyaddr(host.default_ip)[0].split('.', 1)[1]))
 
 
 class RatingError(Exception): pass
 class RatingEngineError(RatingError): pass
 class RatingEngineTimeoutError(TimeoutError): pass
 
 class RatingRequest(str):
     def __init__(self, command, reliable=True, **kwargs):
         self.command = command
         self.reliable = reliable
         self.kwargs = kwargs
         self.deferred = defer.Deferred()
     def __new__(cls, command, reliable=True, **kwargs):
         reqstr = command + (kwargs and (' ' + ' '.join("%s=%s" % (name,value) for name, value in kwargs.items())) or '')
         obj = str.__new__(cls, reqstr)
         return obj
 
 class RatingEngineProtocol(LineOnlyReceiver):
     delimiter = '\n\n'
     def __init__(self):
         self.connected = False
         self.__request = None
         self.__timeout_call = None
         self._request_queue = deque()
     
     def connectionMade(self):
         log.info("Connected to Rating Engine at %s:%d" % (self.transport.getPeer().host, self.transport.getPeer().port))
         self.connected = True
         self.factory.application.connectionMade(self.transport.connector)
         if self._request_queue:
             self._send_next_request()
 
     def connectionLost(self, reason=None):
         log.info("Disconnected from Rating Engine at %s:%d" % (self.transport.getPeer().host, self.transport.getPeer().port))
         self.connected = False
         if self.__request is not None:
             if self.__request.reliable:
                 self._request_queue.appendleft(self.__request)
                 self.__request = None
             else:
                 self._respond("Connection with the Rating Engine is down: %s" % reason, success=False)
         self.factory.application.connectionLost(self.transport.connector, reason, self)
 
     def timeoutConnection(self):
         log.info("Connection to Rating Engine at %s:%d timedout" % (self.transport.getPeer().host, self.transport.getPeer().port))
         self.transport.loseConnection(RatingEngineTimeoutError())
 
     def lineReceived(self, line):
 #        log.debug("Got reply from rating engine: %s" % line) #DEBUG
         if not line:
             return
         if self.__timeout_call is not None:
             self.__timeout_call.cancel()
         if self.__request is None:
             log.warn("Got reply for unexisting request: %s" % line)
             return
         try:
             self._respond(getattr(self, '_PE_%s' % self.__request.command.lower())(line))
         except AttributeError:
             self._respond("Unknown command in request. Cannot handle reply. Reply is: %s" % line, success=False)
         except Exception, e:
             self._respond(str(e), success=False)
 
     def _PE_maxsessiontime(self, line):
         lines = line.splitlines()
 
         try:
             limit = lines[0].strip().capitalize()
         except IndexError:
             raise ValueError("Empty reply from rating engine")
         try:
             limit = int(limit)
         except:
             if limit == 'None':
                 limit = None
             elif limit == 'Locked':
                 pass
             else:
                 raise ValueError("limit must be a non-negative number, None or Locked: %s" % limit)
         else:
             if limit < 0:
                 raise ValueError("limit must be a non-negative number, None or Locked: %s" % limit)
 
         info = dict(line.split('=', 1) for line in lines[1:])
         if 'type' in info:
             type = info['type'].lower()
             if type == 'prepaid':
                 prepaid = True
             elif type == 'postpaid':
                 prepaid = False
             else:
                 raise ValueError("prepaid must be either True or False: %s" % prepaid)
         else:
             prepaid = limit is not None
         return limit, prepaid
 
     def _PE_debitbalance(self, line):
         valid_answers = ('Ok', 'Failed', 'Not prepaid')
         lines = line.splitlines()
         try:
             result = lines[0].strip().capitalize()
         except IndexError:
             raise ValueError("Empty reply from rating engine")
         if result not in valid_answers:
             log.error("Invalid reply from rating engine: `%s'" % lines[0].strip())
             log.warn("Rating engine possible failed query: %s" % self.__request)
             raise RatingEngineError('Invalid rating engine response')
         elif result == 'Failed':
             log.warn("Rating engine failed query: %s" % self.__request)
             raise RatingEngineError('Rating engine failed query')
         else:
             try:
                 timelimit = int(lines[1].split('=', 1)[1].strip())
                 totalcost = lines[2].strip()
             except:
                 log.error("Invalid reply from rating engine for DebitBalance on lines 2, 3: `%s'" % ("', `".join(lines[1:3])))
                 timelimit = None
                 totalcost = 0
             return timelimit, totalcost
 
 
     def _send_next_request(self):
         if self.connected:
             self.__request = self._request_queue.popleft()
             self.sendLine(self.__request)
             self._set_timeout()
 #            log.debug("Sent request to rating engine: %s" % self.__request) #DEBUG
         else:
             self.__request = None
 
     def _respond(self, result, success=True):
         if self.__request is not None:
             req = self.__request
             self.__request = None
             try:
                 if success:
                     req.deferred.callback(result)
                 else:
                     req.deferred.errback(failure.Failure(RatingEngineError(result)))
             except defer.AlreadyCalledError:
                 log.debug("Request %s was already responded to" % str(req))
         if self._request_queue:
             self._send_next_request()
 
     def _set_timeout(self, timeout=None):
         if timeout is None:
             timeout = self.factory.timeout
         self.__timeout_call = reactor.callLater(timeout/1000.0, self.timeoutConnection)
 
     def send_request(self, request):
         if not request.reliable and not self.connected:
             request.deferred.errback(failure.Failure(RatingEngineError("Connection with the Rating Engine is down")))
             return request
         self._request_queue.append(request)
         if self.__request is None:
             self._send_next_request()
         return request
 
 
 class RatingEngineFactory(ReconnectingClientFactory):
     protocol = RatingEngineProtocol
 
     timeout = RatingConfig.timeout
 
     # reconnect parameters
     maxDelay = 15
     factor = maxDelay
     initialDelay = 1.0/factor
     delay = initialDelay
 
     def __init__(self, application):
         self.application = application
 
     def buildProtocol(self, addr):
         self.resetDelay()
         return ReconnectingClientFactory.buildProtocol(self, addr)
 
     def clientConnectionFailed(self, connector, reason):
         if self.application.disconnecting:
             return
         ReconnectingClientFactory.clientConnectionFailed(self, connector, reason)
 
     def clientConnectionLost(self, connector, reason):
         if self.application.disconnecting:
             return
         ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
 
 
 class RatingEngine(object):
     def __init__(self, address):
         self.address = address
         self.disconnecting = False
         self.connector = reactor.connectTCP(self.address[0], self.address[1], factory=RatingEngineFactory(self))
         self.connection = None
         self.__unsent_req = deque()
 
     def shutdown(self):
         self.disconnecting = True
         self.connector.disconnect()
 
     def connectionMade(self, connector):
         self.connection = connector.transport
         self.connection.protocol._request_queue.extend(self.__unsent_req)
         for req in self.__unsent_req:
             log.debug("Requeueing request for the rating engine: %s" % (req,))
         self.__unsent_req.clear()
 
     def connectionLost(self, connector, reason, protocol):
         while protocol._request_queue:
             req = protocol._request_queue.pop()
             if not req.reliable:
                 log.debug("Request is considered failed: %s" % (req,))
                 req.deferred.errback(failure.Failure(RatingEngineError("Connection with the Rating Engine is down")))
             else:
                 log.debug("Saving request to be requeued later: %s" % (req,))
                 self.__unsent_req.appendleft(req)
         self.connection = None
     
     def getCallLimit(self, call, max_duration=CallControlConfig.prepaid_limit, reliable=True):
         max_duration = max_duration or CallControlConfig.limit or 36000
         args = {}
         if call.inprogress:
             args['State'] = 'Connected'
         req = RatingRequest('MaxSessionTime', reliable=reliable, CallId=call.callid, From=call.billingParty, To=call.ruri,
-                          Gateway=call.sourceip, Duration=max_duration, **args)
+                          Gateway=call.sourceip, Duration=max_duration,
+                          Application=call.sip_application, **args)
         if self.connection is not None:
             return self.connection.protocol.send_request(req).deferred
         else:
             self.__unsent_req.append(req)
             return req.deferred
     
     def debitBalance(self, call, reliable=True):
         req = RatingRequest('DebitBalance', reliable=reliable, CallId=call.callid, From=call.billingParty, To=call.ruri,
-                      Gateway=call.sourceip, Duration=call.duration)
+                      Gateway=call.sourceip, Duration=call.duration,
+                      Application=call.sip_application)
         if self.connection is not None:
             return self.connection.protocol.send_request(req).deferred
         else:
             self.__unsent_req.append(req)
             return req.deferred
 
 
 class RatingEngineConnections(object):
     __metaclass__ = Singleton
 
     def __init__(self):
         self.connections = [RatingEngine(engine) for engine in RatingConfig.address]
         self.user_connections = {}
 
     @staticmethod
     def getConnection(call=None):
         engines = RatingEngineConnections()
         conn = random.choice(engines.connections)
         if call is None:
             return conn
         return engines.user_connections.setdefault(call.billingParty, conn)
 
     def remove_user(self, user):
         try:
             del self.user_connections[user]
         except KeyError:
             pass
 
     def shutdown(self):
         for engine in self.connections:
             engine.shutdown()
diff --git a/callcontrol/sip.py b/callcontrol/sip.py
index 95ba6fe..2e2c628 100644
--- a/callcontrol/sip.py
+++ b/callcontrol/sip.py
@@ -1,308 +1,309 @@
 # Copyright (C) 2005-2010 AG Projects. See LICENSE for details.
 #
 
 """
 Implementation of Call objects used to store call information and manage
 a call.
 """
 
 import time
 import re
 
 from application import log
 
 from twisted.internet.error import AlreadyCalled
 from twisted.internet import reactor, defer
 
 from callcontrol.rating import RatingEngineConnections
 from callcontrol.opensips import DialogID, ManagementInterface
 
 
 class CallError(Exception): pass
 
 
 ##
 ## Call data types
 ##
 
 class ReactorTimer(object):
     def __init__(self, delay, function, args=[], kwargs={}):
         self.calldelay = delay
         self.function = function
         self.args = args
         self.kwargs = kwargs
         self.dcall = None
 
     def start(self):
         if self.dcall is None:
             self.dcall = reactor.callLater(self.calldelay, self.function, *self.args, **self.kwargs)
 
     def cancel(self):
         if self.dcall is not None:
             try:
                 self.dcall.cancel()
             except AlreadyCalled:
                 self.dcall = None
 
     def delay(self, seconds):
         if self.dcall is not None:
             try:
                 self.dcall.delay(seconds)
             except AlreadyCalled:
                 self.dcall = None
 
     def reset(self, seconds):
         if self.dcall is not None:
             try:
                 self.dcall.reset(seconds)
             except AlreadyCalled:
                 self.dcall = None
 
 
 class Structure(dict):
     def __init__(self):
         dict.__init__(self)
     def __getitem__(self, key):
         elements = key.split('.')
         obj = self ## start with ourselves
         for e in elements:
             if not isinstance(obj, dict):
                 raise TypeError("unsubscriptable object")
             obj = dict.__getitem__(obj, e)
         return obj
     def __setitem__(self, key, value):
         self.__dict__[key] = value
         dict.__setitem__(self, key, value)
     def __delitem__(self, key):
         dict.__delitem__(self, key)
         del self.__dict__[key]
     __setattr__ = __setitem__
     def __delattr__(self, name):
         try:
             del self.__dict__[name]
         except KeyError:
             raise AttributeError("'%s' object has no attribute '%s'" % (self.__class__.__name__, name))
         else:
             dict.__delitem__(self, name)
     def update(self, other):
         dict.update(self, other)
         for key, value in other.items():
             self.__dict__[key] = value
 
 
 class Call(Structure):
     """Defines a call"""
     def __init__(self, request, application):
         Structure.__init__(self)
         self.prepaid   = request.prepaid
         self.locked    = False ## if the account is locked because another call is in progress
         self.expired   = False ## if call did consume its timelimit before being terminated
         self.created   = time.time()
         self.timer     = None
         self.starttime = None
         self.endtime   = None
         self.timelimit = None
         self.duration  = 0
         self.callid    = request.callid
         self.dialogid  = None
         self.diverter  = request.diverter
         self.ruri      = request.ruri
         self.sourceip  = request.sourceip
         self.token     = request.call_token
+        self.sip_application = request.application # application is used below
         self['from']   = request.from_ ## from is a python keyword
         ## Determine who will pay for the call
         if self.diverter is not None:
             self.billingParty = 'sip:%s' % self.diverter
             self.user = self.diverter
         else:
             match = re.search(r'(?P<address>sip:(?P<user>([^@]+@)?[^\s:;>]+))', request.from_)
             if match is not None:
                 self.billingParty = match.groupdict()['address']
                 self.user = match.groupdict()['user']
             else:
                 self.billingParty = None
                 self.user = None
         self.__initialized = False
         self.application = application
 
     def __str__(self):
         return ("callid=%(callid)s from=%(from)s ruri=%(ruri)s "
                 "diverter=%(diverter)s sourceip=%(sourceip)s "
                 "timelimit=%(timelimit)s status=%%s" % self % self.status)
     
     def __expire(self):
         self.expired = True
         self.application.clean_call(self.callid)
         self.end(reason='call control', sendbye=True)
 
     def setup(self, request):
         """
         Perform call setup when first called (determine time limit and add timer).
         
         If call was previously setup but did not start yet, and the new request
         changes call parameters (ruri, diverter, ...), then update the call
         parameters and redo the setup to update the timer and time limit.
         """
         deferred = defer.Deferred()
         rating = RatingEngineConnections.getConnection(self)
         if not self.__initialized: ## setup called for the first time
             rating.getCallLimit(self, reliable=False).addCallbacks(callback=self._setup_finish_calllimit, errback=self._setup_error, callbackArgs=[deferred], errbackArgs=[deferred])
             return deferred
         elif self.__initialized and self.starttime is None:
             if self.diverter != request.diverter or self.ruri != request.ruri:
                 ## call parameters have changed.
                 ## unlock previous rating request
                 self.prepaid = request.prepaid
                 if self.prepaid and not self.locked:
                     rating.debitBalance(self).addCallbacks(callback=self._setup_finish_debitbalance, errback=self._setup_error, callbackArgs=[request, deferred], errbackArgs=[deferred])
                 else:
                     rating.getCallLimit(self, reliable=False).addCallbacks(callback=self._setup_finish_calllimit, errback=self._setup_error, callbackArgs=[deferred], errbackArgs=[deferred])
                 return deferred
         deferred.callback(None)
         return deferred
 
     def _setup_finish_calllimit(self, (limit, prepaid), deferred):
         if limit == 'Locked':
             self.timelimit = 0
             self.locked = True
         elif limit is not None:
             self.timelimit = limit
         else:
             from callcontrol.controller import CallControlConfig
             self.timelimit = CallControlConfig.limit
         if self.prepaid and not prepaid:
             self.timelimit = 0
             deferred.errback(CallError("Caller %s is regarded as postpaid by the rating engine and prepaid by OpenSIPS" % self.user))
             return
         else:
             self.prepaid = prepaid and limit is not None
         if self.timelimit is not None and self.timelimit > 0:
             self._setup_timer()
         self.__initialized = True
         deferred.callback(None)
 
     def _setup_finish_debitbalance(self, value, request, deferred):
         ## update call paramaters
         self.diverter = request.diverter
         self.ruri     = request.ruri
         if self.diverter is not None:
             self.billingParty = 'sip:%s' % self.diverter
         ## update time limit and timer
         rating = RatingEngineConnections.getConnection(self)
         rating.getCallLimit(self, reliable=False).addCallbacks(callback=self._setup_finish_calllimit, errback=self._setup_error, callbackArgs=[deferred], errbackArgs=[deferred])
 
     def _setup_timer(self, timeout=None):
         if timeout is None:
             timeout = self.timelimit
         self.timer = ReactorTimer(timeout, self.__expire)
 
     def _setup_error(self, fail, deferred):
         deferred.errback(fail)
 
     def start(self, request):
         assert self.__initialized, "Trying to start an unitialized call"
         if self.starttime is None:
             self.dialogid = DialogID(request.dialogid)
             self.starttime = time.time()
             if self.timer is not None:
                 log.info("Call id %s of %s to %s started for maximum %d seconds" % (self.callid, self.user, self.ruri, self.timelimit))
                 self.timer.start()
             # also reset all calls of user to this call's timelimit
             # no reason to alter other calls if this call is not prepaid
             if self.prepaid:
                 rating = RatingEngineConnections.getConnection(self)
                 rating.getCallLimit(self).addCallbacks(callback=self._start_finish_calllimit, errback=self._start_error)
                 for callid in self.application.users[self.billingParty]:
                     if callid == self.callid:
                         continue
                     call = self.application.calls[callid]
                     if not call.prepaid:
                         continue # only alter prepaid calls
                     if call.inprogress:
                         call.timelimit = self.starttime - call.starttime + self.timelimit
                         if call.timer:
                             call.timer.reset(self.timelimit)
                             log.info("Call id %s of %s to %s also set to %d seconds" % (callid, call.user, call.ruri, self.timelimit))
                     elif not call.complete:
                         call.timelimit = self.timelimit
                         call._setup_timer()
 
     def _start_finish_calllimit(self, (limit, prepaid)):
         if limit not in (None, 'Locked'):
             delay = limit - self.timelimit
             for callid in self.application.users[self.billingParty]:
                 call = self.application.calls[callid]
                 if not call.prepaid:
                     continue # only alter prepaid calls
                 if call.inprogress:
                     call.timelimit += delay
                     if call.timer:
                         call.timer.delay(delay)
                         log.info("Call id %s of %s to %s %s maximum %d seconds" % (callid, call.user, call.ruri, (call is self) and 'connected for' or 'previously connected set to', limit))
                 elif not call.complete:
                     call.timelimit = self.timelimit
                     call._setup_timer()
 
     def _start_error(self, fail):
         log.info("Could not get call limit for call id %s of %s to %s" % (self.callid, self.user, self.ruri))
 
     def end(self, calltime=None, reason=None, sendbye=False):
         if sendbye and self.dialogid is not None:
             ManagementInterface().end_dialog(self.dialogid)
         if self.timer:
             self.timer.cancel()
             self.timer = None
         fullreason = '%s%s' % (self.inprogress and 'disconnected' or 'canceled', reason and (' by %s' % reason) or '')
         if self.inprogress:
             self.endtime = time.time()
             duration = self.endtime - self.starttime
             if calltime:
                 ## call did timeout and was ended by external means (like mediaproxy).
                 ## we were notified of this and we have the actual call duration in `calltime'
                 #self.endtime = self.starttime + calltime
                 self.duration = calltime
                 log.info("Call id %s of %s to %s was already disconnected (ended or did timeout) after %s seconds" % (self.callid, self.user, self.ruri, self.duration))
             elif self.expired:
                 self.duration = self.timelimit
                 if duration > self.timelimit + 10:
                     log.warn("Time difference between sending BYEs and actual closing is > 10 seconds")
             else:
                 self.duration = duration
         if self.prepaid and not self.locked and self.timelimit > 0:
             ## even if call was not started we debit 0 seconds anyway to unlock the account
             rating = RatingEngineConnections.getConnection(self)
             rating.debitBalance(self).addCallbacks(callback=self._end_finish, errback=self._end_error, callbackArgs=[reason and fullreason or None])
         elif reason is not None:
             log.info("Call id %s of %s to %s %s%s" % (self.callid, self.user, self.ruri, fullreason, self.duration and (' after %d seconds' % self.duration) or ''))
 
     def _end_finish(self, (timelimit, value), reason):
         if timelimit is not None and timelimit > 0:
             now = time.time()
             for callid in self.application.users.get(self.billingParty, ()):
                 call = self.application.calls[callid]
                 if not call.prepaid:
                     continue # only alter prepaid calls
                 if call.inprogress:
                     call.timelimit = now - call.starttime + timelimit
                     if call.timer:
                         log.info("Call id %s of %s to %s previously connected set to %d seconds" % (callid, call.user, call.ruri, timelimit))
                         call.timer.reset(timelimit)
                 elif not call.complete:
                     call.timelimit = timelimit
                     call._setup_timer()
         # log ended call
         if self.duration > 0:
             log.info("Call id %s of %s to %s %s after %d seconds, call price is %s" % (self.callid, self.user, self.ruri, reason, self.duration, value))
         elif reason is not None:
             log.info("Call id %s of %s to %s %s" % (self.callid, self.user, self.ruri, reason))
  
     def _end_error(self, fail):
         log.info("Could not debit balance for call id %s of %s to %s" % (self.callid, self.user, self.ruri))
     
     status     = property(lambda self: self.inprogress and 'in-progress' or 'pending')
     complete   = property(lambda self: self.dialogid is not None)
     inprogress = property(lambda self: self.starttime is not None and self.endtime is None)
 
 #
 # End Call data types
 #