git.maemo.org Git - ipypbx/blob - src/ipypbx/http.py

   1 # Copyright (c) Stas Shtin, 2010
   2
   3 # This file is part of IPyPBX.
   4
   5 # IPyPBX is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 3 of the License, or
   8 # (at your option) any later version.
   9
  10 # IPyPBX is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14
  15 # You should have received a copy of the GNU General Public License
  16 # along with IPyPBX.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 import xml.etree.ElementTree as etree
  19 from PyQt4 import QtCore, QtNetwork
  20
  21
  22 class FreeswitchConfigServer(QtNetwork.QTcpServer):
  23     """
  24     TCP server that receives config requests from freeswitch.
  25     """
  26     configNotFound = '''
  27 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  28 <document type="freeswitch/xml">
  29   <section name="result">
  30     <result status="not found" />
  31   </section>
  32 </document>
  33     '''
  34     responseTemplate = '''HTTP/1.1 200 OK
  35 Content-Type: text/xml; charset=utf-8
  36 Content-Length: %i
  37
  38 %s'''
  39
  40     def __init__(self, window):
  41         super(FreeswitchConfigServer, self).__init__(window)
  42
  43         self.host = None
  44         self.port = None
  45         self.connection_id = None
  46         self.is_running = False
  47         self.generators = [
  48             GenClass(window, self) for GenClass in (
  49                 SofiaConfGenerator,)]
  50
  51         self.httpRequestParser = HttpRequestParser(self)
  52
  53     def setSocketData(self, host, port, connection_id):
  54         """
  55         Set host and port for socket to listen on.
  56
  57         If the settings differ from previous values, server gets restarted.
  58         """
  59         # Check if restart is needed before new settings are applied.
  60         needs_restart = (
  61             (host, port) != (self.host, self.port)) and connection_id
  62
  63         # Save new settings.
  64         self.host = host
  65         self.port = port
  66         if connection_id:
  67             self.connection_id = connection_id
  68
  69         # Restart server if necessary.
  70         if needs_restart:
  71             self.restartServer()
  72
  73     def startServer(self):
  74         """
  75         Start listening on our socket.
  76         """
  77         if not self.is_running:
  78             if self.host and self.port:
  79                 self.newConnection.connect(self.clientConnecting)
  80                 self.listen(QtNetwork.QHostAddress(self.host), self.port)
  81                 self.is_running = True
  82
  83     def stopServer(self):
  84         """
  85         Stop listening on our socket.
  86         """
  87         if self.is_running:
  88             self.close()
  89             self.is_running = False
  90
  91     def restartServer(self):
  92         """
  93         Restart server.
  94         """
  95         self.stopServer()
  96         self.startServer()
  97
  98     def clientConnecting(self):
  99         """
 100         Handle client connection.
 101         """
 102         if self.hasPendingConnections():
 103             self.socket = self.nextPendingConnection()
 104             self.socket.readyRead.connect(self.receiveData)
 105
 106     def receiveData(self):
 107         # TODO: read in chunks.
 108         for line in str(self.socket.readAll()).split('\r\n'):
 109             print self.httpRequestParser.i, line
 110             self.httpRequestParser.handle(line)
 111
 112         response = self.httpRequestParser.result or self.configNotFound
 113         http_response = self.responseTemplate % (len(response), response)
 114         self.socket.write(http_response)
 115         print
 116         print http_response
 117         print
 118         self.httpRequestParser.reset()
 119         self.socket.close()
 120
 121 class HttpParseError(Exception):
 122     """
 123     Error parsing HTTP request.
 124     """
 125
 126
 127 class HttpRequestParser(object):
 128     """
 129     A simple state machine for parsing HTTP requests.
 130     """
 131     HTTP_NONE, HTTP_REQUEST, HTTP_HEADERS, HTTP_EMPTY, HTTP_MESSAGE, \
 132         HTTP_DONE = range(6)
 133     HTTP_STATES = ['NONE', 'REQUEST', 'HEADERS', 'EMPTY', 'MESSAGE', 'DONE']
 134
 135     def __init__(self, parent):
 136         self.parent = parent
 137         self.i = 0
 138         self.reset()
 139
 140     def reset(self):
 141         """
 142         Reset parser to initial state.
 143         """
 144         self.i += 1
 145         # Initial values for request data.
 146         self.method = None
 147         self.request_path = None
 148         self.http_version = None
 149         self.headers = {}
 150         self.data = {}
 151         self.result = None
 152
 153         # Set initial state.
 154         self.state = self.HTTP_NONE
 155
 156     def handle(self, line):
 157         """
 158         Dispatch line to current state handler.
 159         """
 160         for state in self.HTTP_STATES:
 161             if getattr(self, 'HTTP_%s' % state) == self.state:
 162                 getattr(self, 'handle%s' % state.title())(line)
 163                 break
 164         else:
 165             raise HttpParseError('Unknown HTTP state')
 166
 167     def handleNone(self, line):
 168         """
 169         Pass line to next state.
 170         """
 171         self.state += 1
 172         self.handle(line)
 173
 174     def handleRequest(self, line):
 175         """
 176         Retrieve HTTP method, request path and HTTP version from request.
 177         """
 178         try:
 179             self.method, self.request_path, self.http_version = line.split(' ')
 180             self.state += 1
 181         except ValueError:
 182             pass
 183
 184     def handleHeaders(self, line):
 185         """
 186         Parse headers while not found an empty line.
 187         """
 188         if line:
 189             key, value = line.split(': ')
 190             self.headers[key] = value
 191         else:
 192             self.state += 1
 193             self.handle(line)
 194
 195     def handleEmpty(self, line):
 196         """
 197         Empty line separator is found - proceed to next state.
 198         """
 199         self.state += 1
 200
 201     def handleMessage(self, line):
 202         """
 203         Append to message body.
 204         """
 205         self.data = dict(pair.split('=', 2) for pair in line.split('&'))
 206
 207         #for k, v in self.data.items():
 208         #    print k, '=>', v
 209         #print
 210
 211         for generator in self.parent.generators:
 212             if generator.canHandle(self.data):
 213                 self.state += 1
 214                 self.result = etree.tostring(generator.generateConfig(
 215                     self.headers))
 216                 break
 217
 218
 219 class FreeswitchConfigGenerator(object):
 220     """
 221     Base class for generating XML configs.
 222     """
 223
 224     param_match = {}
 225     section_name = None
 226
 227     def __init__(self, model, parent):
 228         self.model = model
 229         self.parent = parent
 230
 231     def canHandle(self, params):
 232         for key, value in self.param_match.iteritems():
 233             if params.get(key, None) != value:
 234                 return False
 235         else:
 236             return True
 237
 238     def baseElements(self):
 239         root_elt = etree.Element('document', type='freeswitch/xml')
 240         section_elt = etree.SubElement(
 241             root_elt, 'section', name=self.section_name)
 242         return root_elt, section_elt
 243     baseElements = property(baseElements)
 244
 245     def generateConfig(self, params):
 246         return NotImplemented
 247
 248     @staticmethod
 249     def addParams(parent_elt, params):
 250         for name, value in params:
 251             etree.SubElement(
 252                 parent_elt, 'param', name=name, value=str(value))
 253
 254
 255 class SofiaConfGenerator(FreeswitchConfigGenerator):
 256     """
 257     Generates sofia.conf.xml config file.
 258     """
 259     param_match = {'section': 'configuration', 'key_value': 'sofia.conf'}
 260     section_name = 'configuration'
 261     config_name = 'sofia.conf'
 262
 263     def generateConfig(self, params):
 264         # Get base elements.
 265         root_elt, section_elt = self.baseElements
 266
 267         # Create configuration, settings and profiles elements.
 268         configuration_elt = etree.SubElement(
 269             section_elt, 'configuration', name=self.config_name,
 270             description='%s config' % self.config_name)
 271         profiles_elt = etree.SubElement(configuration_elt, 'profiles')
 272
 273         database = self.model.controllers['connection'].model.database()
 274
 275         # Create all profiles for current host.
 276         profiles_query = database.exec_(
 277             '''
 278             select id, name, external_sip_ip, external_rtp_ip, sip_ip, rtp_ip,
 279             sip_port, accept_blind_registration, authenticate_calls
 280             from ipypbxweb_sipprofile where connection_id = %i
 281             ''' % self.parent.connection_id)
 282         while profiles_query.next():
 283             profile_id, _ok = profiles_query.value(0).toInt()
 284             profile_elt = etree.SubElement(
 285                 profiles_elt, 'profile',
 286                 name=profiles_query.value(1).toString())
 287
 288             # Create domains for current profile.
 289             domains_elt = etree.SubElement(profile_elt, 'domains')
 290             domains_query = database.exec_(
 291                 'select host_name from ipypbxweb_domain where sip_profile_id = '
 292                 '%i' % profile_id)
 293             while domains_query.next():
 294                 domain_elt = etree.SubElement(
 295                     domains_elt, 'domain',
 296                     name=domains_query.value(0).toString(), alias='true',
 297                     parse='true')
 298
 299
 300             profile_sip_port, _ok = profiles_query.value(6).toInt()
 301
 302             # Create settings for current profile.
 303             settings_elt = etree.SubElement(profile_elt, 'settings')
 304             params = (
 305                 ('dialplan', 'XML,enum'),
 306                 ('ext-sip-ip', profiles_query.value(2).toString()),
 307                 ('ext-rtp-ip', profiles_query.value(3).toString()),
 308                 ('sip-ip', profiles_query.value(4).toString()),
 309                 ('rtp-ip', profiles_query.value(5).toString()),
 310                 ('sip-port', profile_sip_port),
 311                 ('nonce-ttl', '60'),
 312                 ('rtp-timer-name', 'soft'),
 313                 ('codec-prefs', 'PCMU@20i'),
 314                 ('debug', '1'),
 315                 ('rfc2833-pt', '1'),
 316                 ('dtmf-duration', '100'),
 317                 ('codec-ms', '20'),
 318                 ('accept-blind-reg', profiles_query.value(7).toBool()),
 319                 ('auth-calls', profiles_query.value(8).toBool()))
 320             self.addParams(settings_elt, params)
 321
 322             # Create gateways for current profile.
 323             gateways_elt = etree.SubElement(profile_elt, 'gateways')
 324             gateways_query = database.exec_(
 325                 '''
 326                 select name, username, realm, from_domain, password,
 327                 retry_in_seconds, expire_in_seconds, caller_id_in_from_field,
 328                 extension
 329                 from ipypbxweb_gateway where sip_profile_id = %i
 330                 '''  % profile_id)
 331             while gateways_query.next():
 332                 gateway_elt = etree.SubElement(
 333                     gateways_elt, 'gateway', name=gateways_query.value(0).toString())
 334                 retry_seconds, _ok = gateways_query.value(5).toInt()
 335                 expire_seconds, _ok = gateways_query.value(6).toInt()
 336                 params = (
 337                     ('username', gateways_query.value(1).toString()),
 338                     ('realm', gateways_query.value(2).toString()),
 339                     ('from-domain', gateways_query.value(3).toString()),
 340                     ('password', gateways_query.value(4).toString()),
 341                     ('retry-seconds', retry_seconds),
 342                     ('expire-seconds', expire_seconds),
 343                     ('caller-id-in-from', gateways_query.value(7).toBool()),
 344                     ('extension', gateways_query.value(8).toString()),
 345                     # TODO: proxy, register
 346                     )
 347                 self.addParams(gateway_elt, params)
 348
 349         return root_elt