| #!/usr/bin/env python |
| # Copyright 2011 Google Inc. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| # TR-069 has mandatory attribute names that don't comply with policy |
| # pylint:disable=invalid-name |
| # |
| """The main server process for our TR-069 CPE device.""" |
| |
| __author__ = 'apenwarr@google.com (Avery Pennarun)' |
| |
| # this needs to be first, before any tornado imports |
| import tr.epoll_fix # pylint:disable=g-bad-import-order |
| |
| import errno |
| import os.path |
| import sys |
| import google3 |
| import bup.options |
| import diagui.main |
| import dm_root |
| import factory |
| import tr.acs_config |
| import tr.api |
| import tr.cwmptypes |
| import tr.filenotifier |
| import tr.handle |
| import tr.http |
| import tr.mainloop |
| import tr.rcommand |
| |
| |
| optspec = """ |
| cwmpd [options] |
| -- |
| r,rcmd-port= TCP port to listen for rcommands on; 0 to disable [12999] |
| u,unix-path= Unix socket to listen on [/tmp/cwmpd.sock] |
| i,ip= IP address to report to ACS. (default=finds interface IP address) |
| l,listenip= IP address to listen on [::1] |
| p,port= TCP port to listen for TR-069 on [7547] |
| ping-path= Force CPE ping listener to this URL path (default=random) |
| acs-url= URL of the TR-069 ACS server to connect to |
| fake-acs Run a fake ACS (and auto-set --acs-url to that) |
| no-cpe Don't run a CPE (and thus never connect to ACS) |
| cpe-listener Let CPE listen for http requests (not TR-069 compliant) |
| platform= Activate the platform-specific device tree (see platform/ dir) |
| ext-dir= Activate any extension modules in this dir [%(ext_dir)s] |
| close-stdio Close stdout after listeners are running; exit when stdin closes |
| ca-certs= SSL ca_certificates.crt file to use |
| client-cert= SSL client certificate to use |
| client-key= SSL client private key to use |
| restrict-acs-hosts= Domain names allowed for ACS URL. Default=unrestricted. Example: 'google.com gfsvc.com' |
| diagui Listen for diagui requests on diagui-port |
| diagui-port= Port to listen on (0=random) [80] |
| techui Also handle TechUI requests on the diagui-port |
| licenseui Listen for license requests on the diagui-port |
| factory Listen for factory requests on factory-port |
| factory-port= Port to listen on (0=random) [8883] |
| """ |
| |
| |
| def _GotData(loop, fd, unused_flags): |
| if not os.read(fd, 1024): |
| loop.ioloop.stop() |
| |
| |
| def main(): |
| try: |
| os.mkdir(tr.acs_config.CWMP_TMP_DIR) |
| except OSError, e: |
| if e.errno == errno.EEXIST: |
| pass |
| else: |
| raise |
| cwmpdir = os.path.dirname(os.path.abspath(sys.argv[0])) |
| defargs = dict(ext_dir=os.environ.get('CWMPD_EXT_DIR', cwmpdir + '/ext')) |
| o = bup.options.Options(optspec % defargs) |
| (opt, unused_flags, unused_extra) = o.parse(sys.argv[1:]) |
| |
| if not opt.platform: |
| o.fatal('You must specify a --platform') |
| |
| loop = tr.mainloop.MainLoop() |
| root = dm_root.DeviceModelRoot(loop, opt.platform, opt.ext_dir) |
| root.add_cwmp_extensions() |
| handle = root.handle |
| notifier = tr.filenotifier.FileNotifier(loop) |
| tr.cwmptypes.SetFileBackedNotifier(notifier) |
| acs = cpe = None |
| |
| if opt.fake_acs: |
| if not opt.port: |
| o.fatal("Can't use --fake-acs without --port") |
| acs = tr.api.ACS() |
| if not opt.acs_url: |
| opt.acs_url = 'http://localhost:%d/acs' % opt.port |
| if opt.cpe: |
| cpe = tr.api.CPE(handle) |
| if not opt.cpe_listener: |
| print 'CPE API is client mode only.' |
| |
| if cpe: |
| # Arguments to pass to Tornado HTTPClient.fetch |
| fetch_args = {'user_agent': 'catawampus-tr69'} |
| if opt.ca_certs: |
| fetch_args['ca_certs'] = opt.ca_certs |
| fetch_args['validate_cert'] = True |
| if opt.client_cert and opt.client_key: |
| fetch_args['client_cert'] = opt.client_cert |
| fetch_args['client_key'] = opt.client_key |
| |
| pc = root.get_platform_config(ioloop=loop.ioloop) |
| cpe.download_manager.SetDirectories(config_dir=pc.ConfigDir(), |
| download_dir=pc.DownloadDir()) |
| cpe_machine = tr.http.Listen(ip=opt.ip, port=opt.port, |
| ping_path=opt.ping_path, |
| acs=acs, cpe=cpe, |
| restrict_acs_hosts=opt.restrict_acs_hosts, |
| cpe_listener=opt.cpe_listener, |
| acs_config=tr.acs_config.AcsConfig(), |
| acs_url=opt.acs_url, |
| fetch_args=fetch_args) |
| ms = cpe_machine.GetManagementServer() |
| root.add_management_server(ms) |
| root.configure_tr157(cpe_machine) |
| else: |
| cpe_machine = None |
| |
| if opt.rcmd_port: |
| loop.ListenInet((opt.listenip, opt.rcmd_port), |
| tr.rcommand.MakeRemoteCommandStreamer(handle, cpe_machine)) |
| if opt.unix_path: |
| loop.ListenUnix(opt.unix_path, |
| tr.rcommand.MakeRemoteCommandStreamer(handle, cpe_machine)) |
| if opt.diagui or opt.licenseui: |
| inst = diagui.main.MainApplication(root, cpe_machine, |
| run_diagui=opt.diagui, |
| run_techui=opt.techui, |
| run_licenseui=opt.licenseui) |
| print 'Listening for diagui on port %d' % (opt.diagui_port,) |
| inst.listen(opt.diagui_port) |
| if opt.factory: |
| print 'Listening for factoryui on port %d' % (opt.factory_port,) |
| inst = factory.FactoryFactory() |
| inst.listen(opt.factory_port) |
| |
| if cpe_machine: |
| cpe_machine.Startup() |
| |
| if opt.close_stdio: |
| nullf = open('/dev/null', 'w+') |
| os.dup2(nullf.fileno(), 1) |
| nullf.close() |
| loop.ioloop.add_handler(sys.stdin.fileno(), |
| lambda *args: _GotData(loop, *args), |
| loop.ioloop.READ) |
| |
| loop.Start() |
| |
| |
| if __name__ == '__main__': |
| sys.stdout.flush() |
| sys.stdout = os.fdopen(1, 'w', 1) # force line buffering even if redirected |
| sys.stderr.flush() |
| sys.stderr = os.fdopen(2, 'w', 1) # force line buffering even if redirected |
| print |
| main() |
