def webuistart():
"""Start l2tpgw GUI process.
This assumes that the database and RDF are in good condition.
"""
_log = logger.get('l2tpgw-init-start')
from codebay.l2tpserver import daemonstart
d = daemonstart.DaemonStart(_log)
if _is_livecd():
tac_file = constants.LIVECD_TAC
else:
tac_file = constants.WEBUI_TAC
try:
d.cleanup_daemon(pidfile=constants.WEBUI_PIDFILE)
except:
_log.exception('Failed to cleanup before start, trying to start anyway.')
pass
d.start_daemon(command=constants.WEBUI_COMMAND,
pidfile=constants.WEBUI_PIDFILE, # given to start_daemon even when it doesn't create the pidfile
args=['--pidfile=' + constants.WEBUI_PIDFILE,
'--rundir=/usr/lib/l2tpgw',
'--python=' + tac_file,
'--syslog',
'--no_save'],
background=False, # twistd will fork
make_pidfile=False) # twistd makes pidfile
def __init__(self):
self.install_stage = ''
self.install_info = None
self.hostname = None
self.starttime = None
self.large_install = False
self.position = progressposition.ProgressPosition()
self._log = logger.get('l2tpserver.installer.install')
def webuistop():
_log = logger.get('l2tpgw-init-stop')
from codebay.l2tpserver import daemonstart
d = daemonstart.DaemonStart(_log)
try:
rv = d.stop_daemon(command=constants.WEBUI_COMMAND, pidfile=constants.WEBUI_PIDFILE,
timeout=constants.WEBUI_STOP_TIMEOUT) # give GUI at least this amount of time
except daemonstart.Timeout:
_log.warning('_stop_gui() timed out, using hard kill')
d.hard_stop_daemon(command=constants.WEBUI_COMMAND, pidfile=constants.WEBUI_PIDFILE)
except:
_log.exception('Failed to stop, ignore cleanup actions')
raise
d.cleanup_daemon(pidfile=constants.WEBUI_PIDFILE)
def __init__(self, pub_iface=None, priv_iface=None):
"""Constructor."""
reason = self._safe_getenv("reason")
self._log = logger.get("l2tpserver.dhcpscript.%s" % reason)
self._get_params()
self.outfile = None
if pub_iface is not None and self.params["interface"] == pub_iface:
self.outfile = constants.DHCP_INFORMATION_PUBLIC
self.outfile_backup = (
constants.DHCP_INFORMATION_PUBLIC_NAFTALIN_HACK
) # XXX: required only for 1.0 compatibility
else:
if priv_iface is not None and self.params["interface"] == priv_iface:
self.outfile = constants.DHCP_INFORMATION_PRIVATE
self.outfile_backup = (
constants.DHCP_INFORMATION_PRIVATE_NAFTALIN_HACK
) # XXX: required only for 1.0 compatibility
if self.outfile is None:
m = "Failed to find proper interface to operate on."
self._log.exception(m)
raise Exception(m)
"""Transaction decorators for RDF API.
This functionality has been lifted from the VPNease decorator
(codebay.l2tpserver.db) implementation and very slightly cleaned
up. Hopefully we can generalize this later and make VPNease use
a general version too.
"""
import datetime
import traceback
from twisted.python.util import mergeFunctionMetadata
from codebay.common import logger
_log = logger.get('codebay.rdftransact')
# XXX: globals now
TRANSACT_LOCK_TIME_WARNING_LIMIT = datetime.timedelta(seconds=2)
UNTRANSACT_LOCK_TIME_WARNING_LIMIT = datetime.timedelta(seconds=15*60) # XXX: irrelevant
# XXX: better would be to know the transaction decorator which
# eventually caused the lock to be taken.
toplevel_transaction = None
def _get_func_info(f):
# NB: Function attributes are not always available, so check for each one separately.
# In particular, when a decorator gets an (at least an inner) function, it does not
# have __file__ and __line__.
fname = '<unknown>'
ffile = '<unknown>'
fline = '<unknown>'
"""Functionality to start, stop, and perform various tests on the connection."""
import time, datetime, re, random
from codebay.common import logger
from codebay.common import datatypes
from codebay.l2tpserver import constants
from codebay.l2tpserver import runcommand
from codebay.common import helpers
from codebay.l2tpserver.testclient import locks
import codebay.l2tpserver.testclient.constants as testclientconst # unfortunate naming clash
_log = logger.get('l2tpserver.testclient.testconnection')
run_command = runcommand.run_command
_re_openl2tp_created_tunnel = re.compile(r'^.*?Created\stunnel\s+(\d+)\s*$')
_re_openl2tp_created_session = re.compile(
r'^.*?Created\ssession\s+(\d+)/(\d+)\s*$')
_re_openl2tp_tunnel_details_header = re.compile(
r'^Tunnel\s+(\d+),\s+from\s+(.*?)\s+to\s+([0-9\.]+).*?$')
_re_openl2tp_tunnel_details_udpports = re.compile(
r'^\s+UDP\s+ports:\s+local\s+(\d+?),\s+peer\s+(\d+?)\s*$')
"""
TODO:
- wait for pluto SA
- wait for l2tp tunnel
- wait for l2tp session
- delete session on stop
"""
import re, os, datetime, time, fcntl, tempfile
from codebay.common import rdf
from codebay.common import datatypes
from codebay.common import logger
from codebay.common import randutil
from codebay.common import helpers as common_helpers
from codebay.l2tpserver import runcommand
from codebay.l2tpserver import constants
from codebay.l2tpserver.rdfconfig import ns, ns_ui
from codebay.l2tpserver import db
from codebay.l2tpserver import versioninfo
run_command = runcommand.run_command
_log = logger.get('l2tpserver.helpers')
def get_debug(cfg):
if get_debug_heavy(cfg):
return True
if not cfg.hasS(ns.debug):
return False
debug = cfg.getS(ns.debug)
if debug.hasType(ns.DebugNone):
return False
elif debug.hasType(ns.DebugNormal):
return True
else:
raise Exception('unexpected debug level')
from codebay.common import logger
from codebay.common import randutil
from codebay.common import datatypes
#from codebay.common import twisted_amp as amp
from codebay.common import amphelpers
from codebay.l2tpmanagementprotocol import managementprotocol
from codebay.l2tpmanagementserver import licensemanager
from codebay.l2tpmanagementserver import constants as msconstants
from codebay.l2tpmanagementserver import aptsupport
from codebay.l2tpserver import helpers
from codebay.l2tpserver import runcommand
run_command = runcommand.run_command
_log = logger.get('l2tpmanagementserver.managementserver')
# --------------------------------------------------------------------------
class UpdateManager:
def __init__(self, master, aptcache):
self.master = master
self.aptcache = aptcache
def update_check(self, res, arg_softwareVersion, arg_automaticUpdates, apt_source):
try:
update_available, update_needed, update_immediately, update_forced = False, False, False, False
# FIXME: this must be changed to handle every major version separately (= update "tree")
current_version, current_changelog = self.aptcache.get_apt_info(apt_source)
if current_version is None:
"""Windows XP pages."""
__docformat__ = 'epytext en'
from nevow import inevow, tags as T
import os, formal
from codebay.common import logger
from codebay.l2tpserver import constants
from codebay.l2tpserver.webui import commonpage
from codebay.l2tpserver.webui import uihelpers
_log = logger.get('l2tpserver.webui.user.installation.winxp')
class WindowsXpAutoDetectPage(formal.ResourceMixin,
uihelpers.UserInformationForm,
uihelpers.UserAgentHelpers,
uihelpers.AutoconfigureHelpers,
commonpage.UserPage):
template = 'user/installation/winxp/autodetect.xhtml'
pagetitle = 'Windows XP Autoconfiguration'
next_uri = 'configuration.html'
next_label = 'Configure manually'
class WindowsXpAutoDetectDonePage(uihelpers.AutoconfigureHelpers,
commonpage.UserPopupPage):
template = 'user/installation/winxp/autodetectdone.xhtml'
pagetitle = 'Windows XP Autoconfiguration'
class WindowsXpConfigurationPage(formal.ResourceMixin, uihelpers.UserInformationForm, commonpage.UserPage):
template = 'user/installation/winxp/configuration.xhtml'
Also see:
* http://www.computerworld.com/action/article.do?command=viewArticleBasic&articleId=9020880
"""
__docformat__ = "epytext en"
import textwrap, os
from codebay.common import logger
from codebay.l2tpserver import constants
from codebay.l2tpserver import runcommand
run_command = runcommand.run_command
_log = logger.get("l2tpserver.firefoxconfig")
firefox_global_profile_userjs = "/etc/firefox/profile/user.js"
firefox_global_profile_localstorerdf = "/etc/firefox/profile/localstore.rdf"
firefox_global_profile_bookmarkshtml = "/etc/firefox/profile/bookmarks.html"
_custom_localstore = textwrap.dedent(
"""\
<?xml version="1.0"?>
<RDF:RDF xmlns:NC="http://home.netscape.com/NC-rdf#"
xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<RDF:Description RDF:about="chrome://browser/content/sanitize.xul">
<NC:persist RDF:resource="chrome://browser/content/sanitize.xul#SanitizeDialog"/>
</RDF:Description>
<RDF:Description RDF:about="chrome://browser/content/preferences/fonts.xul#FontsDialog"
screenX="60"
z = zipfiles.ProductZipfile.read_zipfile('/tmp/myfile.zip', filetype=rdfconfig.ns_zipfiles.myZipType)
xml_contents = z.get_file('mydata.xml')
# and so on
"""
__docformat__ = 'epytext en'
import zipfile
from codebay.common import tinyrdf
from codebay.common import logger
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
_log = logger.get('l2tpserver.zipfiles')
# ----------------------------------------------------------------------------
class Error(Exception):
pass
# ----------------------------------------------------------------------------
def _stringify_filetype(filetype):
if isinstance(filetype, str):
return filetype
elif isinstance(filetype, unicode):
return str(filetype)
elif isinstance(filetype, tinyrdf.Uri):
return str(filetype.uri)
crontab_file = '/etc/crontab'
# List of old kernels - these are removed in preinit if they seem to be present.
# Only put *known*, actually deployed VPNease kernel image package names here.
old_kernel_packages = [ 'linux-image-2.6.15-27-386' ]
import os, re, textwrap, tempfile, datetime
# Essential imports
from codebay.common import logger
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
from codebay.l2tpserver import runcommand
from twisted.python.util import mergeFunctionMetadata
_log = logger.get('l2tpgw-init')
run_command = runcommand.run_command
def db_autoclose():
"""Decorator which closes the codebay.l2tpserver.db instance before and after a call.
This ensures that functions which manipulate the shared database close it properly
so that if direct changes to files on disk are done, they appear to other code correctly
"""
def _close_db():
try:
from codebay.l2tpserver import db
db.get_db().close()
except:
_log.exception('failed to close l2tpserver db')
def preinit():
"""Early initialization of l2tpgw.
Stuff to do:
* init runtime directory
* check if this is live-cd and write markerfile if so
* check system memory size and write lowmem marker
* re-check and disable system daemon startups
* live cd: launch opportunistic DHCP client
"""
_log = logger.get('l2tpgw-init-preinit')
try:
helpers.create_rundir()
except:
_log.exception('runtime directory creation failed')
raise
is_livecd = False
try:
is_livecd = _check_livecd(_log)
except:
_log.exception('livecd check failed: ignoring')
try:
_check_memory(_log)
except:
_log.exception('system memory is critically low: ignoring')
try:
_check_daemon_startup(_log)
except:
_log.exception('system daemon startup check failed: ignoring')
# This is here to update 1.0 (or 1.1rc4) naftalin when old vpnease-init
# does not execute l2tpgw-postupdate.
if not is_livecd:
try:
_check_forced_postupdate(_log)
except:
_log.exception('forced postupdate check failed, ignoring')
if not is_livecd:
try:
_remove_old_kernels(_log)
except:
_log.exception('remove old kernels check failed, ignoring')
# Live CD: start opportunistic dhclient as early as possible
if is_livecd:
try:
# Paranoid firewall rules
run_command(['/sbin/iptables', '-F'])
run_command(['/sbin/iptables', '-P', 'OUTPUT', 'ACCEPT'])
run_command(['/sbin/iptables', '-P', 'FORWARD', 'DROP'])
run_command(['/sbin/iptables', '-P', 'INPUT', 'DROP'])
run_command(['/sbin/iptables', '-A', 'INPUT', '-i', 'lo', '-j', 'ACCEPT'])
run_command(['/sbin/iptables', '-A', 'INPUT', '-m', 'state', '--state', 'ESTABLISHED,RELATED', '-j', 'ACCEPT'])
# Dhclient will be launched to background, and will not wait for an address
run_command(['/sbin/dhclient', '-nw', 'eth0']) # XXX: eth0 is fixed now
except:
_log.exception('failed to start dhclient to background (live cd only)')
"""Configure network interfaces."""
__docformat__ = 'epytext en'
import os
from codebay.common import rdf
from codebay.common import datatypes
from codebay.common import logger
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
from codebay.l2tpserver import rdfconfig
from codebay.l2tpserver import runcommand
ns = rdfconfig.ns
run_command = runcommand.run_command
_log = logger.get('l2tpserver.config.interface')
# XXX: constants?
MAX_ETH_DEVICES = 10
class InterfaceConfig:
"""Configure network interfaces."""
def set_rp_filter(self, iface, value):
"""Set RP filter for interface to specific value (boolean).
This writes to /proc/sys directly; iface='all' is OK.
NB: Interface must have an IP address before the relevant
/proc dir will appear.
"""
"""
Monitor a single VPNease server periodically.
Starts an internal task, which monitors a VPNease server periodically.
When a server has been confirmed to have failed, calls a user callback
to notify of a status change.
"""
from twisted.internet import reactor, protocol, defer, error
from twisted.python import failure
from codebay.common import logger
_log = logger.get('l2tpddnsserver.monitor')
class _MonitorPingProtocol(protocol.ProcessProtocol):
def __init__(self, callback):
self.callback = callback
def outReceived(self, data):
pass
def processEnded(self, reason):
self.callback(reason)
class Monitor:
STATUS_UNKNOWN = 'STATUS_UNKNOWN'
STATUS_OK = 'STATUS_OK'
STATUS_NOT_RESPONDING = 'STATUS_NOT_RESPONDING'
def __init__(self, server_address=None, callback=None, interval=60.0):
self.status = self.STATUS_UNKNOWN
"""
Update system time.
Write timestamp when this update was done.
"""
import datetime
try:
from codebay.common import logger
_log = logger.get('l2tpserver.timesync')
except:
_log = None
def _write_update_timestamps():
try:
from codebay.common import datatypes
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
helpers.write_file(constants.TIMESYNC_TIMESTAMP_FILE, datatypes.encode_datetime_to_iso8601_subset(datetime.datetime.utcnow()))
helpers.write_file(constants.TIMESYNC_PERSISTENT_TIMESTAMP_FILE, datatypes.encode_datetime_to_iso8601_subset(datetime.datetime.utcnow()))
except:
if _log is not None:
_log.exception('writing system time update timestamp failed.')
def update_system_time(utc_dt, cap_backwards=None, cap_forwards=None):
"""Update system time to specified UTC timestamp.
The system time 'jump' is capped by optional parameters. The function returns True
if system time has been updated without capping (and without any other errors), and
MAIL_SUBJECT_SUCCESS='%s: all tests ok' % SERVERNAME
MAIL_SUBJECT_FAILURE='%s: some test(s) failed' % SERVERNAME
CMD_MAILX='/usr/bin/mailx'
CMD_PING='/bin/ping'
CMD_WGET='/usr/bin/wget'
CMD_HOST='/usr/bin/host'
import traceback, re, textwrap, os
from codebay.l2tpadmin import runcommand
run_command = runcommand.run_command
from codebay.common import logger
_log = logger.get('monitoringserver')
def _duallog(msg, logf):
print msg
if logf == _log.exception:
traceback.print_exc()
logf(msg)
class DnsMonitor:
"""Monitors DNS name resolving to address(es)."""
def check_name(self, name, addresses):
[rv, out, err] = run_command([CMD_HOST, '-t', 'A', name])
if rv != 0:
import os, sys, time, thread, optparse
from codebay.common import logger
from codebay.common import datatypes
from codebay.l2tpserver import constants
from codebay.l2tpserver import runcommand
from codebay.l2tpserver import daemonstart
from codebay.l2tpserver.testclient import globals
from codebay.l2tpserver.testclient import locks
from codebay.l2tpserver.testclient import systempoller # FIXME
from codebay.l2tpserver.testclient import testconnection
import codebay.l2tpserver.testclient.constants as testclientconst # unfortunate naming clash
_log = logger.get('l2tpserver.testclient.testclient')
run_command = runcommand.run_command
TESTCLIENT_VERSION = '1.0'
# --------------------------------------------------------------------------
class TestRunner:
def _pluto_write_psk(self, psk):
"""Create Pluto pre-shared key file."""
f = open(testclientconst.PLUTO_PSK, 'wb')
f.write(': PSK "%s"\n' % psk)
f.close()
def _pluto_start(self):
"""Product license invoice computation helpers."""
import os
import sys
import gmpy
from twisted.internet import defer
from codebay.common import logger
from codebay.l2tpproductweb import checkeuvatid
_log = logger.get('l2tpproductweb.invoicing')
def compute_partner_discount_oct2007(monthly_inv_vat0):
t = gmpy.mpq(monthly_inv_vat0)
disc = gmpy.mpq(0)
# cumulative discount is computed starting from highest
# discount rate
for [limit, percentage] in [ [ 10000, 30 ],
[ 5000, 25 ],
[ 2500, 20 ],
[ 1000, 15 ],
[ 500, 10 ] ]:
excess = t - gmpy.mpq(limit)
if excess > gmpy.mpq(0):
disc += excess * gmpy.mpq(percentage) / gmpy.mpq(100)
t = limit
return disc
def postinit():
"""Later initialization stuff.
All python code must be available and system update/checks done.
This does the post-install configuration if not done already
and checks and fixes the database and RDF if possible.
Here we also write /fastboot to ensure that fsck is done only
at the periodic reboot time and not on some random reboot.
"""
#
# XXX -- make some operations dependent on 'not livecd' to speed
# up live cd startup time?
#
_log = logger.get('l2tpgw-init-postinit')
is_livecd = _is_livecd()
try:
_record_boot_timestamp(_log)
except:
_log.exception('recording boot timestamp failed: ignoring')
try:
_create_boot_uuid(_log)
except:
_log.exception('creating boot-time uuid failed: ignoring.')
try:
_firstboot_config(_log)
except:
_log.exception('failed to prepare configuration')
raise
try:
_check_system_config(_log)
except:
_log.exception('checking system config failed: ignoring.')
try:
_check_update_rdfxml_export(_log)
except:
_log.exception('update rdfxml import failed: ignoring.')
try:
_check_configuration_import(_log)
except:
_log.exception('configuration import failed: ignoring.')
post_import_failures = False
try:
from codebay.l2tpserver.webui import uidatahelpers
uidatahelpers.fix_missing_database_values()
except:
_log.exception('fix_missing_database_values() failed')
post_import_failures = True
try:
from codebay.l2tpserver.webui import uidatahelpers
pd = uidatahelpers.CreateProtocolData()
pd.save_protocol_data(use_current_config=True)
pd.activate_protocol_data(use_current_config=True)
except:
# NB: failure to generate protocol data will cause database reset;
# this is probably the only sane thing we can do
_log.exception('save_protocol_data() failed')
post_import_failures = True
try:
_rdf_database_checks(_log, post_import_failures)
except:
_log.exception('rdf database checks failed: ignoring.')
try:
_fsck_markers_check(_log)
except:
_log.exception('fsck marker check failed: ignoring.')
try:
_check_interfaces(_log)
except:
_log.exception('network interface check failed: ignoring.')
try:
_cron_tweaks(_log)
except:
_log.exception('cron tweaks failed: ignoring.')
try:
_initial_l2tpgw_cron_run(_log)
except:
_log.exception('initial l2tpgw-cron run failed: ignoring.')
try:
_check_and_generate_gui_certificate(_log)
except:
_log.exception('failed to check and/or generate gui certificate: ignoring.')
try:
_update_ssl_files(_log)
except:
_log.exception('failed to update gui ssl files: ignoring.')
try:
_update_etc_issue(_log, is_livecd)
except:
_log.exception('failed to update /etc/issue: ignoring.')
from codebay.common import rdf
from codebay.common import datatypes
from codebay.common import logger
from codebay.l2tpserver import helpers
from codebay.l2tpserver import db
from codebay.l2tpserver import constants
from codebay.l2tpserver.rdfconfig import ns_ui
from codebay.l2tpserver.webui import uihelpers
from codebay.l2tpserver.webui import uidatahelpers
from codebay.l2tpserver.webui import commonpage
saferender = uihelpers.saferender
_log = logger.get('l2tpserver.webui.admin.config.sitetositeconfig')
class SiteToSitePage(formal.ResourceMixin, commonpage.AdminPage):
"""Creates site to site configuration form."""
template = 'admin/config/sitetositeconfig.xhtml'
pagetitle = 'Configuration / Site-to-Site Connections'
@saferender()
def render_s2s_warning_normal(self, ctx, data):
ui_root = helpers.get_ui_config()
if ui_root.hasS(ns_ui.clientSubnet) and \
(ui_root.getS(ns_ui.clientSubnet, rdf.IPv4Subnet) == datatypes.IPv4Subnet.fromString(uidatahelpers.uidefaults.CLIENT_SUBNET)):
return ''
else:
return ctx.tag
"""Apt helper code for getting product versions and changelog information from package repository."""
import os
import re
import datetime
from codebay.common import logger
from codebay.l2tpserver import helpers
from codebay.l2tpserver import runcommand
from codebay.l2tpserver import versioninfo
run_command = runcommand.run_command
_log = logger.get('l2tpmanagementserver.aptsupport')
_global_aptcache = None
class AptCacheInfo:
def __init__(self, cachetime, version, changelog):
self.cachetime = cachetime
self.version = version
self.changelog = changelog
class AptCache:
"""Get version and changelog information for requested apt sources.list.
Retrieves all information from the package repository using apt, and caches
results for a reasonable period of time to minimize apt traffic.
"""
def __init__(self, interval=2 * 60):
from codebay.l2tpserver import db
root = db.get_db().getRoot()
This will throw an error if the database could not be opened or if the
root node could not be found.
"""
__docformat__ = 'epytext en'
import datetime
import traceback
from twisted.internet import defer
from twisted.python.util import mergeFunctionMetadata
from codebay.common import rdf, logger
_log = logger.get('l2tpserver.db')
TRANSACT_LOCK_TIME_WARNING_LIMIT = datetime.timedelta(seconds=2)
UNTRANSACT_LOCK_TIME_WARNING_LIMIT = datetime.timedelta(seconds=15*60) # XXX: irrelevant
#
# XXX: stack dump for long transactions
#
# XXX: better would be to know the transaction decorator which
# eventually caused the lock to be taken.
toplevel_transaction = None
def _get_func_info(f):
# NB: Function attributes are not always available, so check for each one separately.
# In particular, when a decorator gets an (at least an inner) function, it does not
"""Gnome helpers.
"""
__docformat__ = "epytext en"
import os, sys, string, textwrap
from codebay.common import logger
from codebay.l2tpserver import constants
from codebay.l2tpserver import runcommand
run_command = runcommand.run_command
_log = logger.get("l2tpserver.gnomehelpers")
def show_notification(title, content, timeout=None, critical=False):
"""Show notification through notification-daemon.
The requirements for sending successful notifications using libnotify
are: (1) must have DBUS_SESSION_BUS_ADDRESS environment variable set
correctly, (2) must have correct uid. In practice, 'sudo -u admin'
ensures (2), but (1) needs nasty workarounds. Here we just assume that
someone has kindly written the Dbus information to a file that we use.
Note that DISPLAY is not required for notifications.
"""
FOREVER = 1000000000 # million seconds
# construct a nice environment
try:
myenv = dict(os.environ)
"""Firewall startup and shutdown management."""
__docformat__ = 'epytext en'
import textwrap, re
from codebay.common import rdf
from codebay.common import logger
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
from codebay.l2tpserver import rdfconfig
from codebay.l2tpserver import runcommand
ns = rdfconfig.ns
run_command = runcommand.run_command
_log = logger.get('l2tpserver.config.firewall')
# use with l2tpd
#ppp_interfaces = 'ppp+'
# use with openl2tp
ppp_interfaces = 'l2tp+'
# XXX: handle other link types in addition to ether?
_re_ip_linktype_ether = re.compile(r'^\d:\s([^:]*):.*?link/ether\s.*?$')
class FirewallConfig:
"""Firewall startup and shutdown management."""
def up_firewall_rules(self, cfg, pub_addr, priv_addr, ppp_forced_iface, ppp_forced_gw):
"""Configure and enable firewall rules."""
def __init__(self):
self.configs = []
self._log = logger.get(self.name + '-daemon')
self.d = daemonstart.DaemonStart(self._log)
import os
import formal
from codebay.common import rdf
from codebay.common import logger
from codebay.nevow.formalutils import formalutils
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
from codebay.l2tpserver import db
from codebay.l2tpserver.rdfconfig import ns, ns_ui, ns_zipfiles
from codebay.l2tpserver.webui import commonpage
from codebay.l2tpserver.webui import uihelpers
from codebay.l2tpserver.webui import uidatahelpers
_log = logger.get('l2tpserver.webui.user.changepassword')
class ChangePasswordPage(formal.ResourceMixin, commonpage.UserPage):
template = 'user/changepassword.xhtml'
pagetitle = 'Change Password'
@db.transact()
def render_password_change_allowed(self, ctx, data):
username = self.get_logged_in_username()
user_rdf = uihelpers.find_user(username)
if user_rdf is None:
return ''
else:
return ctx.tag
@db.transact()
import os
from codebay.common import rdf
from codebay.common import logger
from codebay.common import datatypes
from codebay.l2tpserver.webui import commonpage
from codebay.l2tpserver.rdfconfig import ns, ns_ui
from codebay.l2tpserver import db
from codebay.l2tpserver import helpers
from codebay.l2tpserver import constants
from codebay.l2tpserver import rdfdumper
from codebay.l2tpserver import runcommand
run_command = runcommand.run_command
_log = logger.get('l2tpserver.webui.admin.dumps')
class DumpConfigPage(commonpage.AdminPage):
template = 'admin/dumpconfig.xhtml'
pagetitle = 'L2TP/IPsec Configuration Dump'
def render_dump(self, ctx, data):
rd = rdfdumper.RdfDumper()
return rd.dump_resource(db.get_db().getRoot().getS(
ns.l2tpDeviceConfig))
class DumpStatusPage(commonpage.AdminPage):
template = 'admin/dumpstatus.xhtml'
pagetitle = 'L2TP/IPsec Status Dump'
"""Gnome configuration helpers."""
__docformat__ = 'epytext en'
import os, string, textwrap
from codebay.common import logger
_log = logger.get('l2tpserver.update.update')
from codebay.l2tpserver import constants
from codebay.l2tpserver import runcommand
run_command = runcommand.run_command
def _get_browser_url(is_livecd):
"""Get default browser URI for autostart and desktop icon.
This default URI can be different in Live CD and installed system.
"""
if is_livecd:
return 'http://localhost/'
else:
return 'http://localhost/'
def _create_desktop_entry(is_livecd):
"""Create desktop entry contents."""
return textwrap.dedent("""\
[Desktop Entry]
Encoding=UTF-8
Name=%(product)s
Comment=%(product)s Launcher Icon
Exec=/usr/bin/firefox %(url)s
"""License management.
Customer licenses are simply managed as a list of CustomerLicense instances
read from a CSV file. Demo licenses are stored in simple key-value encoded files.
"""
__docformat__ = 'epytext en'
import os, re, datetime, textwrap, md5
from codebay.common import datatypes
from codebay.common import logger
from codebay.common import licensekey
from codebay.l2tpadmin import dbaccess
from codebay.l2tpmanagementprotocol import managementprotocol
from codebay.l2tpmanagementserver import constants as msconstants
_log = logger.get('l2tpmanagementserver.licensemanager')
# FIXME
use_sql = False
class CustomerLicense:
"""Customer license data representation."""
def __init__(self, license_key, validity_start, validity_end, license_string, user_count, s2s_count):
self.license_key = unicode(license_key.upper())
self.validity_start = validity_start
self.validity_end = validity_end
if license_string is None:
self.license_string = unicode("Floating license")
else:
self.license_string = unicode(license_string)
self.user_count = user_count
import os
from codebay.common import logger
_log = logger.get('common.helpers')
def write_file(dest, contents, append=False, perms=0755):
"""Write contents (a string) into a destination file, optionally appending and settings permissions.
By default permissions will be set to 0755. To skip setting permissions altogether
(e.g. for /proc files), set perms=None.
"""
try:
perms_str = 'none'
if perms is not None:
perms_str = '%o' % int(perms)
_log.debug('write_file(dest=%s, perms=%s, append=%s), contents:\n--------\n%s--------\n' % (dest, perms_str, append, contents))
mode = 'w'
if append:
mode = 'a'
f = file(dest, mode)
f.write(contents)
f.close()
if perms is not None:
os.chmod(dest, perms)
except:
_log.exception('write_file failed')
from codebay.common import logger
from codebay.common import rdf
from codebay.l2tpserver import startstop
from codebay.l2tpserver import constants
from codebay.l2tpserver import rdfconfig
from codebay.l2tpserver import runcommand
from codebay.l2tpserver import helpers
from codebay.l2tpserver import rdfdumper
from codebay.l2tpserver import db
ns = rdfconfig.ns
run_command = runcommand.run_command
_log = logger.get('l2tpserver.runner')
class Runner:
def __init__(self):
pass
def usage_and_exit(self):
"""Print usage and exit."""
print textwrap.dedent("""\
Commands: run, resetstate, dumpall, dumpstatus, dumpconfig, status, start, public-interface-test, private-interface-test, route-test, stop.
""")
sys.exit(1)
def runner(self):
try:
from codebay.common import rdf
from codebay.common import datatypes
from codebay.common import logger
from codebay.nevow.formalutils import formdatatypes as dt
from codebay.nevow.formalutils import formalutils
from codebay.l2tpserver.rdfconfig import ns_ui
from codebay.l2tpserver import helpers
from codebay.l2tpserver import db
from codebay.l2tpserver import constants
from codebay.l2tpserver.webui import uihelpers
from codebay.l2tpserver.webui import uidatahelpers
from codebay.l2tpserver.webui import commonpage
_log = logger.get('l2tpserver.webui.admin.users.userconfig')
class UsersPage(formal.ResourceMixin, commonpage.AdminPage):
template = 'admin/users/userconfig.xhtml'
pagetitle = 'Configuration / User Accounts'
def create_radius_group(self, ctx, form):
g = formalutils.CollapsibleGroup('radius', label='RADIUS Servers')
g.setCollapsed(uihelpers.collapse_setting(ns_ui.collapseRadius))
g.add(formalutils.Field('server1', formal.String(required=False), label='Primary RADIUS server address'))
g.add(formalutils.Field('serverport1',
formal.Integer(required=False, validators=[formal.RangeValidator(min=1, max=65535)]),
label='Primary RADIUS server port'))
g.add(formalutils.Field('secret1', formal.String(required=False),
formal.widgetFactory(formalutils.SemiHiddenPassword),
label='Primary RADIUS shared secret'))
"""Mac OS X pages."""
__docformat__ = "epytext en"
from nevow import inevow
import formal
from codebay.common import logger
from codebay.l2tpserver.webui import commonpage
from codebay.l2tpserver.webui import uihelpers
_log = logger.get("l2tpserver.webui.user.installation.osx")
class Osx104AutoDetectPage(
formal.ResourceMixin,
uihelpers.UserInformationForm,
uihelpers.UserAgentHelpers,
uihelpers.AutoconfigureHelpers,
commonpage.UserPage,
):
template = "user/installation/osx104/autodetect.xhtml"
pagetitle = "Mac OS X 10.4 (Tiger) Configuration"
next_uri = "autofinished.html"
next_label = "Next"
class Osx104AutoDetectDonePage(uihelpers.AutoconfigureHelpers, commonpage.UserPopupPage):
template = "user/installation/osx104/autodetectdone.xhtml"
pagetitle = "Mac OS X 10.4 (Tiger) Configuration"
