diff --git a/doc/manuals/vty/sgsn_vty_additions.xml b/doc/manuals/vty/sgsn_vty_additions.xml
index dd26dba..660b695 100644
--- a/doc/manuals/vty/sgsn_vty_additions.xml
+++ b/doc/manuals/vty/sgsn_vty_additions.xml
@@ -1,113 +1,6 @@
 <vtydoc xmlns='urn:osmocom:xml:libosmocore:vty:doc:1.0'>
-    <node id='26'>
-    <child_of nodeid='4' />
-    <name>SGSN Configuration Node</name>
-    <description>Configure the remote GGSN, access-control and other
-    attributes of the SGSN</description>
-	<command id='gtp local-ip A.B.C.D'>
-	<description>
-		Configure the local IP address to which the SGSN should
-		bind for the Gp interface (towards the GGSNs).
-
-		Please note that in case you would like to run the GGSN
-		on the same machine as the SGSN, you can not run both on
-		the same IP address.  It is suggested to use 127.0.0.1
-		for the SGSN and 127.0.0.2 for the GGSN in such
-		situations.
-	</description>
-	</command>
-	<command id='ggsn &lt;0-255&gt; remote-ip A.B.C.D'>
-	<description>
-		Configure a static GGSN with a given numeric identifier
-		to use the specified remote IP address.
-	</description>
-	</command>
-	<command id='ggsn &lt;0-255&gt; gtp-version (0|1)'>
-	<description>
-		Configure whether to use GTPv0 or GTPv1 towards the
-		specified GSSN number.
-	</description>
-	</command>
-	<command id='ggsn dynamic'>
-	<description>
-		Enable dynamic resolving of GGSNs based on DNS resolving
-		the APN name like in a GRX-style setup.  Changing this
-		setting requires a re-start of the SGSN.
-	</description>
-	</command>
-	<command id='grx-dns-add A.B.C.D'>
-	<description>
-		Use the specified IP address for DNS-resolving the AP
-		names to GGSN IP addresses
-	</description>
-	</command>
-	<command id='apn APNAME ggsn &lt;0-255&gt;'>
-	<description>
-		Map the given APN Name to the given GGSN number.
-	</description>
-	</command>
-	<command id='apn APNAME imsi-prefx IMSIPRE ggsn &lt;0-255&gt;'>
-	<description>
-		Map the given APN Name to the given GGSN number _only_
-		if the IMSI matches the given prefix.
-	</description>
-	</command>
-	<command id='imsi-acl (add|del) IMSI'>
-	<description>
-		Add or delete the given IMSI to/from the global Access
-		Control List.
-	</description>
-	</command>
-	<command id='auth-policy (accept-all|closed|acl-only|remote)'>
-	<description>
-		Configure the Authorization policy of the SGSN.  This
-		setting determines which subscribers are permitted to
-		register to the network.
-	</description>
-	</command>
-	<command id='gsup remote-ip A.B.C.D'>
-	<description>
-		Set the IP address of the HLR (gateway) for the GSUP protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='gsup oap-id &lt;0-65535&gt;'>
-	<description>
-		Set the OAP client ID for authentication on the GSUP
-		protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='gsup oap-k K'>
-	<description>
-		Set the OAP shared secret key K for authentication on
-		the GSUP protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='gsup oap-opc OPC'>
-	<description>
-		Set the OAP shared secret OPC for authentication on the
-		GSUP protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='access-point-name NAME'>
-	<description>
-		Globally allow the given APN name for all subscribers.
-	</description>
-	</command>
-	<command id='cdr filename NAME'>
-	<description>
-		Set the file name for the call-data-record file,
-		logging the data usage of each subscriber.
-	</description>
-	</command>
-	<command id='cdr interval &lt;1-2147483647&gt;'>
-	<description>
-		Set the interval (in secodnds) for the call-data-record
-		file.
-	</description>
-	</command>
+    <node id='config-sgsn'>
+	    <description>Configure the remote GGSN, access-control and other
+	    attributes of the SGSN</description>
     </node>
 </vtydoc>
diff --git a/doc/manuals/vty/sgsn_vty_reference.xml b/doc/manuals/vty/sgsn_vty_reference.xml
index 5ec0121..f6e4016 100644
--- a/doc/manuals/vty/sgsn_vty_reference.xml
+++ b/doc/manuals/vty/sgsn_vty_reference.xml
@@ -1,2003 +1,2312 @@
-<vtydoc xmlns='urn:osmocom:xml:libosmocore:vty:doc:1.0'>
-  <node id='0'>
-  </node>
-  <node id='1'>
-    <command id='show version'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='version' doc='Displays program version' />
-      </params>
-    </command>
-    <command id='show online-help'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='online-help' doc='Online help' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='enable'>
-      <params>
-        <param name='enable' doc='Turn on privileged mode command' />
-      </params>
-    </command>
-    <command id='terminal length &lt;0-512&gt;'>
-      <params>
-        <param name='terminal' doc='Set terminal line parameters' />
-        <param name='length' doc='Set number of lines on a screen' />
-        <param name='&lt;0-512&gt;' doc='Number of lines on screen (0 for no pausing)' />
-      </params>
-    </command>
-    <command id='terminal no length'>
-      <params>
-        <param name='terminal' doc='Set terminal line parameters' />
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='length' doc='Set number of lines on a screen' />
-      </params>
-    </command>
-    <command id='echo .MESSAGE'>
-      <params>
-        <param name='echo' doc='Echo a message back to the vty' />
-        <param name='.MESSAGE' doc='The message to echo' />
-      </params>
-    </command>
-    <command id='who'>
-      <params>
-        <param name='who' doc='Display who is on vty' />
-      </params>
-    </command>
-    <command id='show history'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='history' doc='Display the session command history' />
-      </params>
-    </command>
-    <command id='logging enable'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='enable' doc='Enables logging to this vty' />
-      </params>
-    </command>
-    <command id='logging disable'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='disable' doc='Disables logging to this vty' />
-      </params>
-    </command>
-    <command id='logging filter all (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='all' doc='Do you want to log all messages?' />
-        <param name='0' doc='Only print messages matched by other filters' />
-        <param name='1' doc='Bypass filter and print all messages' />
-      </params>
-    </command>
-    <command id='logging color (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='color' doc='Configure color-printing for log messages' />
-        <param name='0' doc='Don&apos;t use color for printing messages' />
-        <param name='1' doc='Use color for printing messages' />
-      </params>
-    </command>
-    <command id='logging timestamp (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='timestamp' doc='Configure log message timestamping' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with current timestamp' />
-      </params>
-    </command>
-    <command id='logging print extended-timestamp (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='print' doc='Log output settings' />
-        <param name='extended-timestamp' doc='Configure log message timestamping' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with current timestamp with YYYYMMDDhhmmssnnn' />
-      </params>
-    </command>
-    <command id='logging print category (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='print' doc='Log output settings' />
-        <param name='category' doc='Configure log message' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with category/subsystem name' />
-      </params>
-    </command>
-    <command id='logging set-log-mask MASK'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='set-log-mask' doc='Set the logmask of this logging target' />
-        <param name='MASK' doc='The logmask to use' />
-      </params>
-    </command>
-    <command id='logging set log mask MASK'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='set' doc='Decide which categories to output.' />
-        <param name='log' doc='Log commands' />
-        <param name='mask' doc='Mask commands' />
-        <param name='MASK' doc='The logmask to use' />
-      </params>
-    </command>
-    <command id='logging level (all|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats) (everything|debug|info|notice|error|fatal)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='level' doc='Set the log level for a specified category' />
-        <param name='all' doc='Global setting for all subsystems' />
-        <param name='mm' doc='Layer3 Mobility Management (MM)' />
-        <param name='pag' doc='Paging Subsystem' />
-        <param name='meas' doc='Radio Measurement Processing' />
-        <param name='ref' doc='Reference Counting' />
-        <param name='gprs' doc='GPRS Packet Service' />
-        <param name='ns' doc='GPRS Network Service (NS)' />
-        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
-        <param name='llc' doc='GPRS Logical Link Control Protocol (LLC)' />
-        <param name='sndcp' doc='GPRS Sub-Network Dependent Control Protocol (SNDCP)' />
-        <param name='slhc' doc='RFC1144 TCP/IP Header compression (SLHC)' />
-        <param name='ranap' doc='RAN Application Part (RANAP)' />
-        <param name='sua' doc='SCCP User Adaptation (SUA)' />
-        <param name='v42bis' doc='V.42bis data compression (SNDCP)' />
-        <param name='lglobal' doc='Library-internal global log family' />
-        <param name='llapd' doc='LAPD in libosmogsm' />
-        <param name='linp' doc='A-bis Intput Subsystem' />
-        <param name='lmux' doc='A-bis B-Subchannel TRAU Frame Multiplex' />
-        <param name='lmi' doc='A-bis Input Driver for Signalling' />
-        <param name='lmib' doc='A-bis Input Driver for B-Channels (voice)' />
-        <param name='lsms' doc='Layer3 Short Message Service (SMS)' />
-        <param name='lctrl' doc='Control Interface' />
-        <param name='lgtp' doc='GPRS GTP library' />
-        <param name='lstats' doc='Statistics messages and logging' />
-        <param name='everything' doc='Don&apos;t use. It doesn&apos;t log anything' />
-        <param name='debug' doc='Log debug messages and higher levels' />
-        <param name='info' doc='Log informational messages and higher levels' />
-        <param name='notice' doc='Log noticeable messages and higher levels' />
-        <param name='error' doc='Log error messages and higher levels' />
-        <param name='fatal' doc='Log only fatal messages' />
-      </params>
-    </command>
-    <command id='show logging vty'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='logging' doc='Show current logging configuration' />
-        <param name='vty' doc='Show current logging configuration for this vty' />
-      </params>
-    </command>
-    <command id='show alarms'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='alarms' doc='Show current logging configuration' />
-      </params>
-    </command>
-    <command id='show stats'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='stats' doc='Show statistical values' />
-      </params>
-    </command>
-    <command id='show stats level (global|peer|subscriber)'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='stats' doc='Show statistical values' />
-        <param name='level' doc='Set the maximum group level' />
-        <param name='global' doc='Show global groups only' />
-        <param name='peer' doc='Show global and network peer related groups' />
-        <param name='subscriber' doc='Show global, peer, and subscriber groups' />
-      </params>
-    </command>
-    <command id='show asciidoc counters'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='asciidoc' doc='Asciidoc generation' />
-        <param name='counters' doc='Generate table of all registered counters' />
-      </params>
-    </command>
-    <command id='show sgsn'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='sgsn' doc='Display information about the SGSN' />
-      </params>
-    </command>
-    <command id='show mm-context imsi IMSI [pdp]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='mm-context' doc='MM Context' />
-        <param name='imsi' doc='Identify by IMSI' />
-        <param name='IMSI' doc='IMSI of the MM Context' />
-        <param name='[pdp]' doc='Include PDP Context Information' />
-      </params>
-    </command>
-    <command id='show mm-context all [pdp]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='mm-context' doc='MM Context' />
-        <param name='all' doc='All MM Contexts' />
-        <param name='[pdp]' doc='Include PDP Context Information' />
-      </params>
-    </command>
-    <command id='show pdp-context all'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='pdp-context' doc='Display information on PDP Context' />
-        <param name='all' doc='Show everything' />
-      </params>
-    </command>
-    <command id='show subscriber cache'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='subscriber' doc='Show information about subscribers' />
-        <param name='cache' doc='Display contents of subscriber cache' />
-      </params>
-    </command>
-    <command id='show ns'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
-      </params>
-    </command>
-    <command id='show ns stats'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
-        <param name='stats' doc='Include statistics' />
-      </params>
-    </command>
-    <command id='show ns (nsei|nsvc) &lt;0-65535&gt; [stats]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
-        <param name='nsei' doc='Select one NSE by its NSE Identifier' />
-        <param name='nsvc' doc='Select one NSE by its NS-VC Identifier' />
-        <param name='&lt;0-65535&gt;' doc='The Identifier of selected type' />
-        <param name='[stats]' doc='Include Statistics' />
-      </params>
-    </command>
-    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='nsvc' doc='Filter based on NS Virtual Connection' />
-        <param name='nsei' doc='Identify NS-VC by NSEI' />
-        <param name='nsvci' doc='Identify NS-VC by NSVCI' />
-        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
-      </params>
-    </command>
-    <command id='show bssgp'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='bssgp' doc='Show information about the BSSGP protocol' />
-      </params>
-    </command>
-    <command id='show bssgp stats'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='bssgp' doc='Show information about the BSSGP protocol' />
-        <param name='stats' doc='Include statistics' />
-      </params>
-    </command>
-    <command id='show bssgp nsei &lt;0-65535&gt; [stats]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='bssgp' doc='Show information about the BSSGP protocol' />
-        <param name='nsei' doc='Show all BVCs on one NSE' />
-        <param name='&lt;0-65535&gt;' doc='The NSEI' />
-        <param name='[stats]' doc='Include Statistics' />
-      </params>
-    </command>
-    <command id='logging filter bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt;'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
-        <param name='nsei' doc='NSEI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
-        <param name='bvci' doc='BVCI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
-      </params>
-    </command>
-    <command id='bssgp bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt; reset'>
-      <params>
-        <param name='bssgp' doc='Initiate BVC RESET procedure for a given NSEI and BVCI' />
-        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
-        <param name='nsei' doc='NSEI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
-        <param name='bvci' doc='BVCI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
-        <param name='reset' doc='Perform reset procedure' />
-      </params>
-    </command>
-    <command id='show llc'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='llc' doc='Display information about the LLC protocol' />
-      </params>
-    </command>
-    <command id='show sndcp'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='sndcp' doc='Display information about the SNDCP protocol' />
-      </params>
-    </command>
-  </node>
-  <node id='2'>
-  </node>
-  <node id='3'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='disable'>
-      <params>
-        <param name='disable' doc='Turn off privileged mode command' />
-      </params>
-    </command>
-    <command id='configure terminal'>
-      <params>
-        <param name='configure' doc='Configuration from vty interface' />
-        <param name='terminal' doc='Configuration terminal' />
-      </params>
-    </command>
-    <command id='copy running-config startup-config'>
-      <params>
-        <param name='copy' doc='Copy configuration' />
-        <param name='running-config' doc='Copy running config to... ' />
-        <param name='startup-config' doc='Copy running config to startup config (same as write file)' />
-      </params>
-    </command>
-    <command id='show startup-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='startup-config' doc='Contentes of startup configuration' />
-      </params>
-    </command>
-    <command id='show version'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='version' doc='Displays program version' />
-      </params>
-    </command>
-    <command id='show online-help'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='online-help' doc='Online help' />
-      </params>
-    </command>
-    <command id='terminal length &lt;0-512&gt;'>
-      <params>
-        <param name='terminal' doc='Set terminal line parameters' />
-        <param name='length' doc='Set number of lines on a screen' />
-        <param name='&lt;0-512&gt;' doc='Number of lines on screen (0 for no pausing)' />
-      </params>
-    </command>
-    <command id='terminal no length'>
-      <params>
-        <param name='terminal' doc='Set terminal line parameters' />
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='length' doc='Set number of lines on a screen' />
-      </params>
-    </command>
-    <command id='echo .MESSAGE'>
-      <params>
-        <param name='echo' doc='Echo a message back to the vty' />
-        <param name='.MESSAGE' doc='The message to echo' />
-      </params>
-    </command>
-    <command id='who'>
-      <params>
-        <param name='who' doc='Display who is on vty' />
-      </params>
-    </command>
-    <command id='show history'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='history' doc='Display the session command history' />
-      </params>
-    </command>
-    <command id='terminal monitor'>
-      <params>
-        <param name='terminal' doc='Set terminal line parameters' />
-        <param name='monitor' doc='Copy debug output to the current terminal line' />
-      </params>
-    </command>
-    <command id='terminal no monitor'>
-      <params>
-        <param name='terminal' doc='Set terminal line parameters' />
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='monitor' doc='Copy debug output to the current terminal line' />
-      </params>
-    </command>
-    <command id='logging enable'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='enable' doc='Enables logging to this vty' />
-      </params>
-    </command>
-    <command id='logging disable'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='disable' doc='Disables logging to this vty' />
-      </params>
-    </command>
-    <command id='logging filter all (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='all' doc='Do you want to log all messages?' />
-        <param name='0' doc='Only print messages matched by other filters' />
-        <param name='1' doc='Bypass filter and print all messages' />
-      </params>
-    </command>
-    <command id='logging color (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='color' doc='Configure color-printing for log messages' />
-        <param name='0' doc='Don&apos;t use color for printing messages' />
-        <param name='1' doc='Use color for printing messages' />
-      </params>
-    </command>
-    <command id='logging timestamp (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='timestamp' doc='Configure log message timestamping' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with current timestamp' />
-      </params>
-    </command>
-    <command id='logging print extended-timestamp (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='print' doc='Log output settings' />
-        <param name='extended-timestamp' doc='Configure log message timestamping' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with current timestamp with YYYYMMDDhhmmssnnn' />
-      </params>
-    </command>
-    <command id='logging print category (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='print' doc='Log output settings' />
-        <param name='category' doc='Configure log message' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with category/subsystem name' />
-      </params>
-    </command>
-    <command id='logging set-log-mask MASK'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='set-log-mask' doc='Set the logmask of this logging target' />
-        <param name='MASK' doc='The logmask to use' />
-      </params>
-    </command>
-    <command id='logging set log mask MASK'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='set' doc='Decide which categories to output.' />
-        <param name='log' doc='Log commands' />
-        <param name='mask' doc='Mask commands' />
-        <param name='MASK' doc='The logmask to use' />
-      </params>
-    </command>
-    <command id='logging level (all|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats) (everything|debug|info|notice|error|fatal)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='level' doc='Set the log level for a specified category' />
-        <param name='all' doc='Global setting for all subsystems' />
-        <param name='mm' doc='Layer3 Mobility Management (MM)' />
-        <param name='pag' doc='Paging Subsystem' />
-        <param name='meas' doc='Radio Measurement Processing' />
-        <param name='ref' doc='Reference Counting' />
-        <param name='gprs' doc='GPRS Packet Service' />
-        <param name='ns' doc='GPRS Network Service (NS)' />
-        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
-        <param name='llc' doc='GPRS Logical Link Control Protocol (LLC)' />
-        <param name='sndcp' doc='GPRS Sub-Network Dependent Control Protocol (SNDCP)' />
-        <param name='slhc' doc='RFC1144 TCP/IP Header compression (SLHC)' />
-        <param name='ranap' doc='RAN Application Part (RANAP)' />
-        <param name='sua' doc='SCCP User Adaptation (SUA)' />
-        <param name='v42bis' doc='V.42bis data compression (SNDCP)' />
-        <param name='lglobal' doc='Library-internal global log family' />
-        <param name='llapd' doc='LAPD in libosmogsm' />
-        <param name='linp' doc='A-bis Intput Subsystem' />
-        <param name='lmux' doc='A-bis B-Subchannel TRAU Frame Multiplex' />
-        <param name='lmi' doc='A-bis Input Driver for Signalling' />
-        <param name='lmib' doc='A-bis Input Driver for B-Channels (voice)' />
-        <param name='lsms' doc='Layer3 Short Message Service (SMS)' />
-        <param name='lctrl' doc='Control Interface' />
-        <param name='lgtp' doc='GPRS GTP library' />
-        <param name='lstats' doc='Statistics messages and logging' />
-        <param name='everything' doc='Don&apos;t use. It doesn&apos;t log anything' />
-        <param name='debug' doc='Log debug messages and higher levels' />
-        <param name='info' doc='Log informational messages and higher levels' />
-        <param name='notice' doc='Log noticeable messages and higher levels' />
-        <param name='error' doc='Log error messages and higher levels' />
-        <param name='fatal' doc='Log only fatal messages' />
-      </params>
-    </command>
-    <command id='show logging vty'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='logging' doc='Show current logging configuration' />
-        <param name='vty' doc='Show current logging configuration for this vty' />
-      </params>
-    </command>
-    <command id='show alarms'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='alarms' doc='Show current logging configuration' />
-      </params>
-    </command>
-    <command id='show stats'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='stats' doc='Show statistical values' />
-      </params>
-    </command>
-    <command id='show stats level (global|peer|subscriber)'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='stats' doc='Show statistical values' />
-        <param name='level' doc='Set the maximum group level' />
-        <param name='global' doc='Show global groups only' />
-        <param name='peer' doc='Show global and network peer related groups' />
-        <param name='subscriber' doc='Show global, peer, and subscriber groups' />
-      </params>
-    </command>
-    <command id='show asciidoc counters'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='asciidoc' doc='Asciidoc generation' />
-        <param name='counters' doc='Generate table of all registered counters' />
-      </params>
-    </command>
-    <command id='show sgsn'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='sgsn' doc='Display information about the SGSN' />
-      </params>
-    </command>
-    <command id='show mm-context imsi IMSI [pdp]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='mm-context' doc='MM Context' />
-        <param name='imsi' doc='Identify by IMSI' />
-        <param name='IMSI' doc='IMSI of the MM Context' />
-        <param name='[pdp]' doc='Include PDP Context Information' />
-      </params>
-    </command>
-    <command id='show mm-context all [pdp]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='mm-context' doc='MM Context' />
-        <param name='all' doc='All MM Contexts' />
-        <param name='[pdp]' doc='Include PDP Context Information' />
-      </params>
-    </command>
-    <command id='show pdp-context all'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='pdp-context' doc='Display information on PDP Context' />
-        <param name='all' doc='Show everything' />
-      </params>
-    </command>
-    <command id='show subscriber cache'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='subscriber' doc='Show information about subscribers' />
-        <param name='cache' doc='Display contents of subscriber cache' />
-      </params>
-    </command>
-    <command id='update-subscriber imsi IMSI insert auth-triplet &lt;1-5&gt; sres SRES rand RAND kc KC'>
-      <params>
-        <param name='update-subscriber' doc='Update subscriber list' />
-        <param name='imsi' doc='Use the IMSI to select the subscriber' />
-        <param name='IMSI' doc='The IMSI' />
-        <param name='insert' doc='Insert data into the subscriber record' />
-        <param name='auth-triplet' doc='Update authentication triplet' />
-        <param name='&lt;1-5&gt;' doc='Triplet index' />
-        <param name='sres' doc='Set SRES value' />
-        <param name='SRES' doc='SRES value (4 byte) in hex' />
-        <param name='rand' doc='Set RAND value' />
-        <param name='RAND' doc='RAND value (16 byte) in hex' />
-        <param name='kc' doc='Set Kc value' />
-        <param name='KC' doc='Kc value (8 byte) in hex' />
-      </params>
-    </command>
-    <command id='update-subscriber imsi IMSI create'>
-      <params>
-        <param name='update-subscriber' doc='Update subscriber list' />
-        <param name='imsi' doc='Use the IMSI to select the subscriber' />
-        <param name='IMSI' doc='The IMSI' />
-        <param name='create' doc='Create a subscriber entry' />
-      </params>
-    </command>
-    <command id='update-subscriber imsi IMSI destroy'>
-      <params>
-        <param name='update-subscriber' doc='Update subscriber list' />
-        <param name='imsi' doc='Use the IMSI to select the subscriber' />
-        <param name='IMSI' doc='The IMSI' />
-        <param name='destroy' doc='Destroy a subscriber entry' />
-      </params>
-    </command>
-    <command id='update-subscriber imsi IMSI cancel (update-procedure|subscription-withdraw)'>
-      <params>
-        <param name='update-subscriber' doc='Update subscriber list' />
-        <param name='imsi' doc='Use the IMSI to select the subscriber' />
-        <param name='IMSI' doc='The IMSI' />
-        <param name='cancel' doc='Cancel (remove) subscriber record' />
-        <param name='update-procedure' doc='The MS moved to another SGSN' />
-        <param name='subscription-withdraw' doc='The subscription is no longer valid' />
-      </params>
-    </command>
-    <command id='update-subscriber imsi IMSI update-location-result (ok|system-failure|data-missing|unexpected-data-value|unknown-subscriber|roaming-not-allowed)'>
-      <params>
-        <param name='update-subscriber' doc='Update subscriber list' />
-        <param name='imsi' doc='Use the IMSI to select the subscriber' />
-        <param name='IMSI' doc='The IMSI' />
-        <param name='update-location-result' doc='Complete the update location procedure' />
-        <param name='ok' doc='The update location request succeeded' />
-        <param name='system-failure' doc='Force error code SystemFailure' />
-        <param name='data-missing' doc='Force error code DataMissing' />
-        <param name='unexpected-data-value' doc='Force error code UnexpectedDataValue' />
-        <param name='unknown-subscriber' doc='Force error code UnknownSubscriber' />
-        <param name='roaming-not-allowed' doc='Force error code RoamingNotAllowed' />
-      </params>
-    </command>
-    <command id='update-subscriber imsi IMSI update-auth-info'>
-      <params>
-        <param name='update-subscriber' doc='Update subscriber list' />
-        <param name='imsi' doc='Use the IMSI to select the subscriber' />
-        <param name='IMSI' doc='The IMSI' />
-        <param name='update-auth-info' doc='Complete the send authentication info procedure' />
-      </params>
-    </command>
-    <command id='show ns'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
-      </params>
-    </command>
-    <command id='show ns stats'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
-        <param name='stats' doc='Include statistics' />
-      </params>
-    </command>
-    <command id='show ns (nsei|nsvc) &lt;0-65535&gt; [stats]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
-        <param name='nsei' doc='Select one NSE by its NSE Identifier' />
-        <param name='nsvc' doc='Select one NSE by its NS-VC Identifier' />
-        <param name='&lt;0-65535&gt;' doc='The Identifier of selected type' />
-        <param name='[stats]' doc='Include Statistics' />
-      </params>
-    </command>
-    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='nsvc' doc='Filter based on NS Virtual Connection' />
-        <param name='nsei' doc='Identify NS-VC by NSEI' />
-        <param name='nsvci' doc='Identify NS-VC by NSVCI' />
-        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
-      </params>
-    </command>
-    <command id='nsvc (nsei|nsvci) &lt;0-65535&gt; (block|unblock|reset)'>
-      <params>
-        <param name='nsvc' doc='Perform an operation on a NSVC' />
-        <param name='nsei' doc='NSEI to identify NS-VC Identifier (NS-VCI)' />
-        <param name='nsvci' doc='NS-VC Identifier (NS-VCI)' />
-        <param name='&lt;0-65535&gt;' doc='The NSEI' />
-        <param name='block' doc='Initiate BLOCK procedure' />
-        <param name='unblock' doc='Initiate UNBLOCK procedure' />
-        <param name='reset' doc='Initiate RESET procedure' />
-      </params>
-    </command>
-    <command id='show bssgp'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='bssgp' doc='Show information about the BSSGP protocol' />
-      </params>
-    </command>
-    <command id='show bssgp stats'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='bssgp' doc='Show information about the BSSGP protocol' />
-        <param name='stats' doc='Include statistics' />
-      </params>
-    </command>
-    <command id='show bssgp nsei &lt;0-65535&gt; [stats]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='bssgp' doc='Show information about the BSSGP protocol' />
-        <param name='nsei' doc='Show all BVCs on one NSE' />
-        <param name='&lt;0-65535&gt;' doc='The NSEI' />
-        <param name='[stats]' doc='Include Statistics' />
-      </params>
-    </command>
-    <command id='logging filter bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt;'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
-        <param name='nsei' doc='NSEI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
-        <param name='bvci' doc='BVCI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
-      </params>
-    </command>
-    <command id='bssgp bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt; reset'>
-      <params>
-        <param name='bssgp' doc='Initiate BVC RESET procedure for a given NSEI and BVCI' />
-        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
-        <param name='nsei' doc='NSEI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
-        <param name='bvci' doc='BVCI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
-        <param name='reset' doc='Perform reset procedure' />
-      </params>
-    </command>
-    <command id='show llc'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='llc' doc='Display information about the LLC protocol' />
-      </params>
-    </command>
-    <command id='show sndcp'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='sndcp' doc='Display information about the SNDCP protocol' />
-      </params>
-    </command>
-  </node>
-  <node id='4'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-    <command id='hostname WORD'>
-      <params>
-        <param name='hostname' doc='Set system&apos;s network name' />
-        <param name='WORD' doc='This system&apos;s network name' />
-      </params>
-    </command>
-    <command id='no hostname [HOSTNAME]'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='hostname' doc='Reset system&apos;s network name' />
-        <param name='[HOSTNAME]' doc='Host name of this router' />
-      </params>
-    </command>
-    <command id='password (8|) WORD'>
-      <params>
-        <param name='password' doc='Assign the terminal connection password' />
-        <param name='8' doc='Specifies a HIDDEN password will follow' />
-        <param name='' doc='dummy string ' />
-        <param name='WORD' doc='The HIDDEN line password string' />
-      </params>
-    </command>
-    <command id='password LINE'>
-      <params>
-        <param name='password' doc='Assign the terminal connection password' />
-        <param name='LINE' doc='The UNENCRYPTED (cleartext) line password' />
-      </params>
-    </command>
-    <command id='enable password (8|) WORD'>
-      <params>
-        <param name='enable' doc='Modify enable password parameters' />
-        <param name='password' doc='Assign the privileged level password' />
-        <param name='8' doc='Specifies a HIDDEN password will follow' />
-        <param name='' doc='dummy string ' />
-        <param name='WORD' doc='The HIDDEN &apos;enable&apos; password string' />
-      </params>
-    </command>
-    <command id='enable password LINE'>
-      <params>
-        <param name='enable' doc='Modify enable password parameters' />
-        <param name='password' doc='Assign the privileged level password' />
-        <param name='LINE' doc='The UNENCRYPTED (cleartext) &apos;enable&apos; password' />
-      </params>
-    </command>
-    <command id='no enable password'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='enable' doc='Modify enable password parameters' />
-        <param name='password' doc='Assign the privileged level password' />
-      </params>
-    </command>
-    <command id='banner motd default'>
-      <params>
-        <param name='banner' doc='Set banner string' />
-        <param name='motd' doc='Strings for motd' />
-        <param name='default' doc='Default string' />
-      </params>
-    </command>
-    <command id='banner motd file [FILE]'>
-      <params>
-        <param name='banner' doc='Set banner' />
-        <param name='motd' doc='Banner for motd' />
-        <param name='file' doc='Banner from a file' />
-        <param name='[FILE]' doc='Filename' />
-      </params>
-    </command>
-    <command id='no banner motd'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='banner' doc='Set banner string' />
-        <param name='motd' doc='Strings for motd' />
-      </params>
-    </command>
-    <command id='service terminal-length &lt;0-512&gt;'>
-      <params>
-        <param name='service' doc='Set up miscellaneous service' />
-        <param name='terminal-length' doc='System wide terminal length configuration' />
-        <param name='&lt;0-512&gt;' doc='Number of lines of VTY (0 means no line control)' />
-      </params>
-    </command>
-    <command id='no service terminal-length [&lt;0-512&gt;]'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='service' doc='Set up miscellaneous service' />
-        <param name='terminal-length' doc='System wide terminal length configuration' />
-        <param name='[&lt;0-512&gt;]' doc='Number of lines of VTY (0 means no line control)' />
-      </params>
-    </command>
-    <command id='line vty'>
-      <params>
-        <param name='line' doc='Configure a terminal line' />
-        <param name='vty' doc='Virtual terminal' />
-      </params>
-    </command>
-    <command id='service advanced-vty'>
-      <params>
-        <param name='service' doc='Set up miscellaneous service' />
-        <param name='advanced-vty' doc='Enable advanced mode vty interface' />
-      </params>
-    </command>
-    <command id='no service advanced-vty'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='service' doc='Set up miscellaneous service' />
-        <param name='advanced-vty' doc='Enable advanced mode vty interface' />
-      </params>
-    </command>
-    <command id='show history'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='history' doc='Display the session command history' />
-      </params>
-    </command>
-    <command id='log stderr'>
-      <params>
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='stderr' doc='Logging via STDERR of the process' />
-      </params>
-    </command>
-    <command id='no log stderr'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='stderr' doc='Logging via STDERR of the process' />
-      </params>
-    </command>
-    <command id='log file .FILENAME'>
-      <params>
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='file' doc='Logging to text file' />
-        <param name='.FILENAME' doc='Filename' />
-      </params>
-    </command>
-    <command id='no log file .FILENAME'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='file' doc='Logging to text file' />
-        <param name='.FILENAME' doc='Filename' />
-      </params>
-    </command>
-    <command id='log alarms &lt;2-32700&gt;'>
-      <params>
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='alarms' doc='Logging alarms to osmo_strrb' />
-        <param name='&lt;2-32700&gt;' doc='Maximum number of messages to log' />
-      </params>
-    </command>
-    <command id='no log alarms'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='alarms' doc='Logging alarms to osmo_strrb' />
-      </params>
-    </command>
-    <command id='log syslog (authpriv|cron|daemon|ftp|lpr|mail|news|user|uucp)'>
-      <params>
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='syslog' doc='Logging via syslog' />
-        <param name='authpriv' doc='Security/authorization messages facility' />
-        <param name='cron' doc='Clock daemon (cron/at) facility' />
-        <param name='daemon' doc='General system daemon facility' />
-        <param name='ftp' doc='Ftp daemon facility' />
-        <param name='lpr' doc='Line printer facility' />
-        <param name='mail' doc='Mail facility' />
-        <param name='news' doc='News facility' />
-        <param name='user' doc='Generic facility' />
-        <param name='uucp' doc='UUCP facility' />
-      </params>
-    </command>
-    <command id='log syslog local &lt;0-7&gt;'>
-      <params>
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='syslog' doc='Logging via syslog' />
-        <param name='local' doc='Syslog LOCAL facility' />
-        <param name='&lt;0-7&gt;' doc='Local facility number' />
-      </params>
-    </command>
-    <command id='no log syslog'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='syslog' doc='Logging via syslog' />
-      </params>
-    </command>
-    <command id='log gsmtap [HOSTNAME]'>
-      <params>
-        <param name='log' doc='Configure logging sub-system' />
-        <param name='gsmtap' doc='Logging via GSMTAP' />
-        <param name='[HOSTNAME]' doc='Host name to send the GSMTAP logging to (UDP port 4729)' />
-      </params>
-    </command>
-    <command id='stats reporter statsd'>
-      <params>
-        <param name='stats' doc='Configure stats sub-system' />
-        <param name='reporter' doc='Configure a stats reporter' />
-        <param name='statsd' doc='Report to a STATSD server' />
-      </params>
-    </command>
-    <command id='no stats reporter statsd'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='stats' doc='Configure stats sub-system' />
-        <param name='reporter' doc='Configure a stats reporter' />
-        <param name='statsd' doc='Report to a STATSD server' />
-      </params>
-    </command>
-    <command id='stats reporter log'>
-      <params>
-        <param name='stats' doc='Configure stats sub-system' />
-        <param name='reporter' doc='Configure a stats reporter' />
-        <param name='log' doc='Report to the logger' />
-      </params>
-    </command>
-    <command id='no stats reporter log'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='stats' doc='Configure stats sub-system' />
-        <param name='reporter' doc='Configure a stats reporter' />
-        <param name='log' doc='Report to the logger' />
-      </params>
-    </command>
-    <command id='stats interval &lt;1-65535&gt;'>
-      <params>
-        <param name='stats' doc='Configure stats sub-system' />
-        <param name='interval' doc='Set the reporting interval' />
-        <param name='&lt;1-65535&gt;' doc='Interval in seconds' />
-      </params>
-    </command>
-    <command id='sgsn'>
-      <params>
-        <param name='sgsn' doc='Configure the SGSN' />
-      </params>
-    </command>
-    <command id='ctrl'>
-      <params>
-        <param name='ctrl' doc='Configure the Control Interface' />
-      </params>
-    </command>
-    <command id='ns'>
-      <params>
-        <param name='ns' doc='Configure the GPRS Network Service' />
-      </params>
-    </command>
-    <command id='bssgp'>
-      <params>
-        <param name='bssgp' doc='Configure the GPRS BSS Gateway Protocol' />
-      </params>
-    </command>
-  </node>
-  <node id='7'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-    <command id='logging filter all (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='all' doc='Do you want to log all messages?' />
-        <param name='0' doc='Only print messages matched by other filters' />
-        <param name='1' doc='Bypass filter and print all messages' />
-      </params>
-    </command>
-    <command id='logging color (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='color' doc='Configure color-printing for log messages' />
-        <param name='0' doc='Don&apos;t use color for printing messages' />
-        <param name='1' doc='Use color for printing messages' />
-      </params>
-    </command>
-    <command id='logging timestamp (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='timestamp' doc='Configure log message timestamping' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with current timestamp' />
-      </params>
-    </command>
-    <command id='logging print extended-timestamp (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='print' doc='Log output settings' />
-        <param name='extended-timestamp' doc='Configure log message timestamping' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with current timestamp with YYYYMMDDhhmmssnnn' />
-      </params>
-    </command>
-    <command id='logging print category (0|1)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='print' doc='Log output settings' />
-        <param name='category' doc='Configure log message' />
-        <param name='0' doc='Don&apos;t prefix each log message' />
-        <param name='1' doc='Prefix each log message with category/subsystem name' />
-      </params>
-    </command>
-    <command id='logging level (all|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats) (everything|debug|info|notice|error|fatal)'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='level' doc='Set the log level for a specified category' />
-        <param name='all' doc='Global setting for all subsystems' />
-        <param name='mm' doc='Layer3 Mobility Management (MM)' />
-        <param name='pag' doc='Paging Subsystem' />
-        <param name='meas' doc='Radio Measurement Processing' />
-        <param name='ref' doc='Reference Counting' />
-        <param name='gprs' doc='GPRS Packet Service' />
-        <param name='ns' doc='GPRS Network Service (NS)' />
-        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
-        <param name='llc' doc='GPRS Logical Link Control Protocol (LLC)' />
-        <param name='sndcp' doc='GPRS Sub-Network Dependent Control Protocol (SNDCP)' />
-        <param name='slhc' doc='RFC1144 TCP/IP Header compression (SLHC)' />
-        <param name='ranap' doc='RAN Application Part (RANAP)' />
-        <param name='sua' doc='SCCP User Adaptation (SUA)' />
-        <param name='v42bis' doc='V.42bis data compression (SNDCP)' />
-        <param name='lglobal' doc='Library-internal global log family' />
-        <param name='llapd' doc='LAPD in libosmogsm' />
-        <param name='linp' doc='A-bis Intput Subsystem' />
-        <param name='lmux' doc='A-bis B-Subchannel TRAU Frame Multiplex' />
-        <param name='lmi' doc='A-bis Input Driver for Signalling' />
-        <param name='lmib' doc='A-bis Input Driver for B-Channels (voice)' />
-        <param name='lsms' doc='Layer3 Short Message Service (SMS)' />
-        <param name='lctrl' doc='Control Interface' />
-        <param name='lgtp' doc='GPRS GTP library' />
-        <param name='lstats' doc='Statistics messages and logging' />
-        <param name='everything' doc='Don&apos;t use. It doesn&apos;t log anything' />
-        <param name='debug' doc='Log debug messages and higher levels' />
-        <param name='info' doc='Log informational messages and higher levels' />
-        <param name='notice' doc='Log noticeable messages and higher levels' />
-        <param name='error' doc='Log error messages and higher levels' />
-        <param name='fatal' doc='Log only fatal messages' />
-      </params>
-    </command>
-    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='nsvc' doc='Filter based on NS Virtual Connection' />
-        <param name='nsei' doc='Identify NS-VC by NSEI' />
-        <param name='nsvci' doc='Identify NS-VC by NSVCI' />
-        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
-      </params>
-    </command>
-    <command id='logging filter bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt;'>
-      <params>
-        <param name='logging' doc='Configure log message to this terminal' />
-        <param name='filter' doc='Filter log messages' />
-        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
-        <param name='nsei' doc='NSEI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
-        <param name='bvci' doc='BVCI of the BVC to be filtered' />
-        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
-      </params>
-    </command>
-  </node>
-  <node id='8'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-    <command id='local-ip ADDR'>
-      <params>
-        <param name='local-ip' doc='Set the IP address to which we bind locally' />
-        <param name='ADDR' doc='IP Address' />
-      </params>
-    </command>
-    <command id='no local-ip'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='local-ip' doc='Set the IP address to which we bind locally' />
-      </params>
-    </command>
-    <command id='remote-ip ADDR'>
-      <params>
-        <param name='remote-ip' doc='Set the remote IP address to which we connect' />
-        <param name='ADDR' doc='IP Address' />
-      </params>
-    </command>
-    <command id='remote-port &lt;1-65535&gt;'>
-      <params>
-        <param name='remote-port' doc='Set the remote port to which we connect' />
-        <param name='&lt;1-65535&gt;' doc='Remote port number' />
-      </params>
-    </command>
-    <command id='mtu &lt;100-65535&gt;'>
-      <params>
-        <param name='mtu' doc='Set the maximum packet size' />
-        <param name='&lt;100-65535&gt;' doc='Size in byte' />
-      </params>
-    </command>
-    <command id='no mtu'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='mtu' doc='Set the maximum packet size' />
-      </params>
-    </command>
-    <command id='prefix PREFIX'>
-      <params>
-        <param name='prefix' doc='Set the item name prefix' />
-        <param name='PREFIX' doc='The prefix string' />
-      </params>
-    </command>
-    <command id='no prefix'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='prefix' doc='Set the item name prefix' />
-      </params>
-    </command>
-    <command id='level (global|peer|subscriber)'>
-      <params>
-        <param name='level' doc='Set the maximum group level' />
-        <param name='global' doc='Report global groups only' />
-        <param name='peer' doc='Report global and network peer related groups' />
-        <param name='subscriber' doc='Report global, peer, and subscriber groups' />
-      </params>
-    </command>
-    <command id='enable'>
-      <params>
-        <param name='enable' doc='Enable the reporter' />
-      </params>
-    </command>
-    <command id='disable'>
-      <params>
-        <param name='disable' doc='Disable the reporter' />
-      </params>
-    </command>
-  </node>
-  <node id='9'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-    <command id='login'>
-      <params>
-        <param name='login' doc='Enable password checking' />
-      </params>
-    </command>
-    <command id='no login'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='login' doc='Enable password checking' />
-      </params>
-    </command>
-    <command id='bind A.B.C.D'>
-      <params>
-        <param name='bind' doc='Accept VTY telnet connections on local interface' />
-        <param name='A.B.C.D' doc='Local interface IP address (default: 127.0.0.1)' />
-      </params>
-    </command>
-  </node>
-  <node id='12'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-    <command id='nse &lt;0-65535&gt; nsvci &lt;0-65534&gt;'>
-      <params>
-        <param name='nse' doc='Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-        <param name='nsvci' doc='NS Virtual Connection' />
-        <param name='&lt;0-65534&gt;' doc='NS Virtual Connection ID (NSVCI)' />
-      </params>
-    </command>
-    <command id='nse &lt;0-65535&gt; remote-ip A.B.C.D'>
-      <params>
-        <param name='nse' doc='Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-        <param name='remote-ip' doc='Remote IP Address' />
-        <param name='A.B.C.D' doc='Remote IP Address' />
-      </params>
-    </command>
-    <command id='nse &lt;0-65535&gt; remote-port &lt;0-65535&gt;'>
-      <params>
-        <param name='nse' doc='Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-        <param name='remote-port' doc='Remote UDP Port' />
-        <param name='&lt;0-65535&gt;' doc='Remote UDP Port Number' />
-      </params>
-    </command>
-    <command id='nse &lt;0-65535&gt; fr-dlci &lt;16-1007&gt;'>
-      <params>
-        <param name='nse' doc='Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-        <param name='fr-dlci' doc='Frame Relay DLCI' />
-        <param name='&lt;16-1007&gt;' doc='Frame Relay DLCI Number' />
-      </params>
-    </command>
-    <command id='nse &lt;0-65535&gt; encapsulation (udp|framerelay-gre)'>
-      <params>
-        <param name='nse' doc='Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-        <param name='encapsulation' doc='Encapsulation for NS' />
-        <param name='udp' doc='UDP/IP Encapsulation' />
-        <param name='framerelay-gre' doc='Frame-Relay/GRE/IP Encapsulation' />
-      </params>
-    </command>
-    <command id='nse &lt;0-65535&gt; remote-role (sgsn|bss)'>
-      <params>
-        <param name='nse' doc='Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-        <param name='remote-role' doc='Remote NSE Role' />
-        <param name='sgsn' doc='Remote Peer is SGSN' />
-        <param name='bss' doc='Remote Peer is BSS' />
-      </params>
-    </command>
-    <command id='no nse &lt;0-65535&gt;'>
-      <params>
-        <param name='no' doc='Delete Persistent NS Entity' />
-        <param name='nse' doc='Delete Persistent NS Entity' />
-        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
-      </params>
-    </command>
-    <command id='timer (tns-block|tns-block-retries|tns-reset|tns-reset-retries|tns-test|tns-alive|tns-alive-retries) &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Network Service Timer' />
-        <param name='tns-block' doc='(un)blocking Timer (Tns-block) timeout' />
-        <param name='tns-block-retries' doc='(un)blocking Timer (Tns-block) number of retries' />
-        <param name='tns-reset' doc='Reset Timer (Tns-reset) timeout' />
-        <param name='tns-reset-retries' doc='Reset Timer (Tns-reset) number of retries' />
-        <param name='tns-test' doc='Test Timer (Tns-test) timeout' />
-        <param name='tns-alive' doc='Alive Timer (Tns-alive) timeout' />
-        <param name='tns-alive-retries' doc='Alive Timer (Tns-alive) number of retries' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value' />
-      </params>
-    </command>
-    <command id='encapsulation udp local-ip A.B.C.D'>
-      <params>
-        <param name='encapsulation' doc='NS encapsulation options' />
-        <param name='udp' doc='NS over UDP Encapsulation' />
-        <param name='local-ip' doc='Set the IP address on which we listen for NS/UDP' />
-        <param name='A.B.C.D' doc='IP Address' />
-      </params>
-    </command>
-    <command id='encapsulation udp local-port &lt;0-65535&gt;'>
-      <params>
-        <param name='encapsulation' doc='NS encapsulation options' />
-        <param name='udp' doc='NS over UDP Encapsulation' />
-        <param name='local-port' doc='Set the UDP port on which we listen for NS/UDP' />
-        <param name='&lt;0-65535&gt;' doc='UDP port number' />
-      </params>
-    </command>
-    <command id='encapsulation udp dscp &lt;0-255&gt;'>
-      <params>
-        <param name='encapsulation' doc='NS encapsulation options' />
-        <param name='udp' doc='NS over UDP Encapsulation' />
-        <param name='dscp' doc='Set DSCP/TOS on the UDP socket' />
-        <param name='&lt;0-255&gt;' doc='DSCP Value' />
-      </params>
-    </command>
-    <command id='encapsulation framerelay-gre enabled (1|0)'>
-      <params>
-        <param name='encapsulation' doc='NS encapsulation options' />
-        <param name='framerelay-gre' doc='NS over Frame Relay over GRE Encapsulation' />
-        <param name='enabled' doc='Enable or disable Frame Relay over GRE' />
-        <param name='1' doc='Enable' />
-        <param name='0' doc='Disable' />
-      </params>
-    </command>
-    <command id='encapsulation framerelay-gre local-ip A.B.C.D'>
-      <params>
-        <param name='encapsulation' doc='NS encapsulation options' />
-        <param name='framerelay-gre' doc='NS over Frame Relay over GRE Encapsulation' />
-        <param name='local-ip' doc='Set the IP address on which we listen for NS/FR/GRE' />
-        <param name='A.B.C.D' doc='IP Address' />
-      </params>
-    </command>
-  </node>
-  <node id='13'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-  </node>
-  <node id='14'>
-    <command id='bind A.B.C.D'>
-      <params>
-        <param name='bind' doc='Set bind address to listen for Control connections' />
-        <param name='A.B.C.D' doc='Local IP address (default 127.0.0.1)' />
-      </params>
-    </command>
-  </node>
-  <node id='26'>
-    <command id='help'>
-      <params>
-        <param name='help' doc='Description of the interactive help system' />
-      </params>
-    </command>
-    <command id='list'>
-      <params>
-        <param name='list' doc='Print command list' />
-      </params>
-    </command>
-    <command id='write terminal'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='terminal' doc='Write to terminal' />
-      </params>
-    </command>
-    <command id='write file'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-      </params>
-    </command>
-    <command id='write memory'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='memory' doc='Write configuration to the file (same as write file)' />
-      </params>
-    </command>
-    <command id='write'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-      </params>
-    </command>
-    <command id='show running-config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='running-config' doc='running configuration' />
-      </params>
-    </command>
-    <command id='exit'>
-      <params>
-        <param name='exit' doc='Exit current mode and down to previous mode' />
-      </params>
-    </command>
-    <command id='end'>
-      <params>
-        <param name='end' doc='End current mode and change to enable mode.' />
-      </params>
-    </command>
-    <command id='gtp local-ip A.B.C.D'>
-      <params>
-        <param name='gtp' doc='GTP Parameters' />
-        <param name='local-ip' doc='Set the IP address for the local GTP bind' />
-        <param name='A.B.C.D' doc='IPv4 Address' />
-      </params>
-    </command>
-    <command id='ggsn &lt;0-255&gt; remote-ip A.B.C.D'>
-      <params>
-        <param name='ggsn' doc='Configure the GGSN information' />
-        <param name='&lt;0-255&gt;' doc='GGSN Number' />
-        <param name='remote-ip' doc='IP information' />
-        <param name='A.B.C.D' doc='IPv4 Address' />
-      </params>
-    </command>
-    <command id='ggsn &lt;0-255&gt; gtp-version (0|1)'>
-      <params>
-        <param name='ggsn' doc='Configure the GGSN information' />
-        <param name='&lt;0-255&gt;' doc='GGSN Number' />
-        <param name='gtp-version' doc='GTP Version' />
-        <param name='0' doc='Version 0' />
-        <param name='1' doc='Version 1' />
-      </params>
-    </command>
-    <command id='imsi-acl (add|del) IMSI'>
-      <params>
-        <param name='imsi-acl' doc='Access Control List of foreign IMSIs' />
-        <param name='add' doc='Add IMSI to ACL' />
-        <param name='del' doc='Remove IMSI from ACL' />
-        <param name='IMSI' doc='IMSI of subscriber' />
-      </params>
-    </command>
-    <command id='auth-policy (accept-all|closed|acl-only|remote)'>
-      <params>
-        <param name='auth-policy' doc='Autorization Policy of SGSN' />
-        <param name='accept-all' doc='Accept all IMSIs (DANGEROUS)' />
-        <param name='closed' doc='Accept only home network subscribers or those in the ACL' />
-        <param name='acl-only' doc='Accept only subscribers in the ACL' />
-        <param name='remote' doc='Use remote subscription data only (HLR)' />
-      </params>
-    </command>
-    <command id='encryption (GEA0|GEA1|GEA2|GEA3|GEA4)'>
-      <params>
-        <param name='encryption' doc='Set encryption algorithm for SGSN' />
-        <param name='GEA0' doc='Use GEA0 (no encryption)' />
-        <param name='GEA1' doc='Use GEA1' />
-        <param name='GEA2' doc='Use GEA2' />
-        <param name='GEA3' doc='Use GEA3' />
-        <param name='GEA4' doc='Use GEA4' />
-      </params>
-    </command>
-    <command id='gsup remote-ip A.B.C.D'>
-      <params>
-        <param name='gsup' doc='GSUP Parameters' />
-        <param name='remote-ip' doc='Set the IP address of the remote GSUP server' />
-        <param name='A.B.C.D' doc='IPv4 Address' />
-      </params>
-    </command>
-    <command id='gsup remote-port &lt;0-65535&gt;'>
-      <params>
-        <param name='gsup' doc='GSUP Parameters' />
-        <param name='remote-port' doc='Set the TCP port of the remote GSUP server' />
-        <param name='&lt;0-65535&gt;' doc='Remote TCP port' />
-      </params>
-    </command>
-    <command id='gsup oap-id &lt;0-65535&gt;'>
-      <params>
-        <param name='gsup' doc='GSUP Parameters' />
-        <param name='oap-id' doc='Set the SGSN&apos;s OAP client ID' />
-        <param name='&lt;0-65535&gt;' doc='OAP client ID (0 == disabled)' />
-      </params>
-    </command>
-    <command id='gsup oap-k K'>
-      <params>
-        <param name='gsup' doc='GSUP Parameters' />
-        <param name='oap-k' doc='Set the OAP shared secret K' />
-        <param name='K' doc='K value (16 byte) hex' />
-      </params>
-    </command>
-    <command id='gsup oap-opc OPC'>
-      <params>
-        <param name='gsup' doc='GSUP Parameters' />
-        <param name='oap-opc' doc='Set the OAP shared secret OPC' />
-        <param name='OPC' doc='OPC value (16 byte) hex' />
-      </params>
-    </command>
-    <command id='apn APNAME ggsn &lt;0-255&gt;'>
-      <params>
-        <param name='apn' doc='Configure the information per APN' />
-        <param name='APNAME' doc='The APN gateway name optionally prefixed by &apos;*&apos; (wildcard)' />
-        <param name='ggsn' doc='Select the GGSN to use when the APN gateway prefix matches' />
-        <param name='&lt;0-255&gt;' doc='The GGSN id' />
-      </params>
-    </command>
-    <command id='apn APNAME imsi-prefix IMSIPRE ggsn &lt;0-255&gt;'>
-      <params>
-        <param name='apn' doc='Configure the information per APN' />
-        <param name='APNAME' doc='The APN gateway name optionally prefixed by &apos;*&apos; (wildcard)' />
-        <param name='imsi-prefix' doc='Restrict rule to a certain IMSI prefix' />
-        <param name='IMSIPRE' doc='An IMSI prefix' />
-        <param name='ggsn' doc='Select the GGSN to use when APN gateway and IMSI prefix match' />
-        <param name='&lt;0-255&gt;' doc='The GGSN id' />
-      </params>
-    </command>
-    <command id='access-point-name NAME'>
-      <params>
-        <param name='access-point-name' doc='Configure a global list of allowed APNs' />
-        <param name='NAME' doc='Add this NAME to the list' />
-      </params>
-    </command>
-    <command id='no access-point-name NAME'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='access-point-name' doc='Configure a global list of allowed APNs' />
-        <param name='NAME' doc='Remove entry with NAME' />
-      </params>
-    </command>
-    <command id='cdr filename NAME'>
-      <params>
-        <param name='cdr' doc='CDR' />
-        <param name='filename' doc='Set filename' />
-        <param name='NAME' doc='name' />
-      </params>
-    </command>
-    <command id='no cdr filename'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='cdr' doc='CDR' />
-        <param name='filename' doc='Disable CDR generation' />
-      </params>
-    </command>
-    <command id='cdr interval &lt;1-2147483647&gt;'>
-      <params>
-        <param name='cdr' doc='CDR' />
-        <param name='interval' doc='PDP periodic log interval' />
-        <param name='&lt;1-2147483647&gt;' doc='Seconds' />
-      </params>
-    </command>
-    <command id='ggsn dynamic'>
-      <params>
-        <param name='ggsn' doc='Configure the GGSN information' />
-        <param name='dynamic' doc='Enable dynamic GRX based look-up (requires restart)' />
-      </params>
-    </command>
-    <command id='grx-dns-add A.B.C.D'>
-      <params>
-        <param name='grx-dns-add' doc='Add DNS server' />
-        <param name='A.B.C.D' doc='IPv4 address' />
-      </params>
-    </command>
-    <command id='timer t3312 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3312' doc='Periodic RA Update timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3322 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3322' doc='Detach request -&gt; accept timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3350 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3350' doc='Waiting for ATT/RAU/TMSI_COMPL timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3360 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3360' doc='Waiting for AUTH/CIPH response timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3370 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3370' doc='Waiting for IDENTITY response timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3313 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3313' doc='Waiting for paging response timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3314 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3314' doc='Force to STANDBY on expiry timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3316 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3316' doc='AA-Ready timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3385 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3385' doc='Wait for ACT PDP CTX REQ timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3386 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3386' doc='Wait for MODIFY PDP CTX ACK timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3395 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3395' doc='Wait for DEACT PDP CTX ACK timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='timer t3397 &lt;0-65535&gt;'>
-      <params>
-        <param name='timer' doc='Configure GPRS Timers' />
-        <param name='t3397' doc='Wait for DEACT AA PDP CTX ACK timer (s)' />
-        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
-      </params>
-    </command>
-    <command id='no compression rfc1144'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='compression' doc='Configure compression' />
-        <param name='rfc1144' doc='disable rfc1144 TCP/IP header compression' />
-      </params>
-    </command>
-    <command id='compression rfc1144 active slots &lt;1-256&gt;'>
-      <params>
-        <param name='compression' doc='Configure compression' />
-        <param name='rfc1144' doc='RFC1144 Header compresion scheme' />
-        <param name='active' doc='Compression is actively proposed' />
-        <param name='slots' doc='Number of compression state slots' />
-        <param name='&lt;1-256&gt;' doc='Number of compression state slots' />
-      </params>
-    </command>
-    <command id='compression rfc1144 passive'>
-      <params>
-        <param name='compression' doc='Configure compression' />
-        <param name='rfc1144' doc='RFC1144 Header compresion scheme' />
-        <param name='passive' doc='Compression is available on request' />
-      </params>
-    </command>
-    <command id='no compression v42bis'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='compression' doc='Configure compression' />
-        <param name='v42bis' doc='disable V.42bis data compression' />
-      </params>
-    </command>
-    <command id='compression v42bis active direction (ms|sgsn|both) codewords &lt;512-65535&gt; strlen &lt;6-250&gt;'>
-      <params>
-        <param name='compression' doc='Configure compression' />
-        <param name='v42bis' doc='V.42bis data compresion scheme' />
-        <param name='active' doc='Compression is actively proposed' />
-        <param name='direction' doc='Direction in which the compression shall be active (p0)' />
-        <param name='ms' doc='Compress ms-&gt;sgsn direction only' />
-        <param name='sgsn' doc='Compress sgsn-&gt;ms direction only' />
-        <param name='both' doc='Both directions' />
-        <param name='codewords' doc='Number of codewords (p1)' />
-        <param name='&lt;512-65535&gt;' doc='Number of codewords' />
-        <param name='strlen' doc='Maximum string length (p2)' />
-        <param name='&lt;6-250&gt;' doc='Maximum string length' />
-      </params>
-    </command>
-    <command id='compression v42bis passive'>
-      <params>
-        <param name='compression' doc='Configure compression' />
-        <param name='v42bis' doc='V.42bis data compresion scheme' />
-        <param name='passive' doc='Compression is available on request' />
-      </params>
-    </command>
-  </node>
-</vtydoc>
+<vtydoc xmlns='urn:osmocom:xml:libosmocore:vty:doc:1.0'>
+  <node id='_common_cmds_'>
+    <name>Common Commands</name>
+    <description>These commands are available on all VTY nodes. They are listed here only once, to unclutter the VTY reference.</description>
+    <command id='help'>
+      <params>
+        <param name='help' doc='Description of the interactive help system' />
+      </params>
+    </command>
+    <command id='list'>
+      <params>
+        <param name='list' doc='Print command list' />
+      </params>
+    </command>
+    <command id='write terminal'>
+      <params>
+        <param name='write' doc='Write running configuration to memory, network, or terminal' />
+        <param name='terminal' doc='Write to terminal' />
+      </params>
+    </command>
+    <command id='write file'>
+      <params>
+        <param name='write' doc='Write running configuration to memory, network, or terminal' />
+        <param name='file' doc='Write to configuration file' />
+      </params>
+    </command>
+    <command id='write memory'>
+      <params>
+        <param name='write' doc='Write running configuration to memory, network, or terminal' />
+        <param name='memory' doc='Write configuration to the file (same as write file)' />
+      </params>
+    </command>
+    <command id='write'>
+      <params>
+        <param name='write' doc='Write running configuration to memory, network, or terminal' />
+      </params>
+    </command>
+    <command id='show running-config'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='running-config' doc='running configuration' />
+      </params>
+    </command>
+    <command id='exit'>
+      <params>
+        <param name='exit' doc='Exit current mode and down to previous mode' />
+      </params>
+    </command>
+    <command id='end'>
+      <params>
+        <param name='end' doc='End current mode and change to enable mode.' />
+      </params>
+    </command>
+  </node>
+  <node id='view'>
+    <name>view</name>
+    <command id='show version'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='version' doc='Displays program version' />
+      </params>
+    </command>
+    <command id='show online-help'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='online-help' doc='Online help' />
+      </params>
+    </command>
+    <command id='enable'>
+      <params>
+        <param name='enable' doc='Turn on privileged mode command' />
+      </params>
+    </command>
+    <command id='terminal length &lt;0-512&gt;'>
+      <params>
+        <param name='terminal' doc='Set terminal line parameters' />
+        <param name='length' doc='Set number of lines on a screen' />
+        <param name='&lt;0-512&gt;' doc='Number of lines on screen (0 for no pausing)' />
+      </params>
+    </command>
+    <command id='terminal no length'>
+      <params>
+        <param name='terminal' doc='Set terminal line parameters' />
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='length' doc='Set number of lines on a screen' />
+      </params>
+    </command>
+    <command id='echo .MESSAGE'>
+      <params>
+        <param name='echo' doc='Echo a message back to the vty' />
+        <param name='.MESSAGE' doc='The message to echo' />
+      </params>
+    </command>
+    <command id='who'>
+      <params>
+        <param name='who' doc='Display who is on vty' />
+      </params>
+    </command>
+    <command id='show history'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='history' doc='Display the session command history' />
+      </params>
+    </command>
+    <command id='logging enable'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='enable' doc='Enables logging to this vty' />
+      </params>
+    </command>
+    <command id='logging disable'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='disable' doc='Disables logging to this vty' />
+      </params>
+    </command>
+    <command id='logging filter all (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='all' doc='Do you want to log all messages?' />
+        <param name='0' doc='Only print messages matched by other filters' />
+        <param name='1' doc='Bypass filter and print all messages' />
+      </params>
+    </command>
+    <command id='logging color (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='color' doc='Configure color-printing for log messages' />
+        <param name='0' doc='Don&apos;t use color for printing messages' />
+        <param name='1' doc='Use color for printing messages' />
+      </params>
+    </command>
+    <command id='logging timestamp (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='timestamp' doc='Configure log message timestamping' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with current timestamp' />
+      </params>
+    </command>
+    <command id='logging print extended-timestamp (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='extended-timestamp' doc='Configure log message timestamping' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with current timestamp with YYYYMMDDhhmmssnnn' />
+      </params>
+    </command>
+    <command id='logging print category (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='category' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with category/subsystem name' />
+      </params>
+    </command>
+    <command id='logging print category-hex (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='category-hex' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with category/subsystem nr in hex (&apos;&lt;000b&gt;&apos;)' />
+      </params>
+    </command>
+    <command id='logging print level (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='level' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with the log level name' />
+      </params>
+    </command>
+    <command id='logging print file (0|1|basename)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='file' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with the source file and line' />
+        <param name='basename' doc='Prefix each log message with the source file&apos;s basename (strip leading paths) and line' />
+      </params>
+    </command>
+    <command id='logging set-log-mask MASK'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='set-log-mask' doc='Set the logmask of this logging target' />
+        <param name='MASK' doc='List of logging categories to log, e.g. &apos;abc:mno:xyz&apos;. Available log categories depend on the specific application, refer to the &apos;logging level&apos; command. Optionally add individual log levels like &apos;abc,1:mno,3:xyz,5&apos;, where the level numbers are LOGL_DEBUG=1 LOGL_INFO=3 LOGL_NOTICE=5 LOGL_ERROR=7 LOGL_FATAL=8' />
+      </params>
+    </command>
+    <command id='logging set log mask MASK'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='set' doc='Decide which categories to output.' />
+        <param name='log' doc='Log commands' />
+        <param name='mask' doc='Mask commands' />
+        <param name='MASK' doc='&apos;set log mask&apos; is deprecated, please refer to the docs of &apos;set-log-mask&apos; instead' />
+      </params>
+    </command>
+    <command id='logging level (all|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf) (everything|debug|info|notice|error|fatal)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='level' doc='Set the log level for a specified category' />
+        <param name='all' doc='Global setting for all subsystems' />
+        <param name='mm' doc='Layer3 Mobility Management (MM)' />
+        <param name='pag' doc='Paging Subsystem' />
+        <param name='meas' doc='Radio Measurement Processing' />
+        <param name='ref' doc='Reference Counting' />
+        <param name='gprs' doc='GPRS Packet Service' />
+        <param name='ns' doc='GPRS Network Service (NS)' />
+        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
+        <param name='llc' doc='GPRS Logical Link Control Protocol (LLC)' />
+        <param name='sndcp' doc='GPRS Sub-Network Dependent Control Protocol (SNDCP)' />
+        <param name='slhc' doc='RFC1144 TCP/IP Header compression (SLHC)' />
+        <param name='ranap' doc='RAN Application Part (RANAP)' />
+        <param name='sua' doc='SCCP User Adaptation (SUA)' />
+        <param name='v42bis' doc='V.42bis data compression (SNDCP)' />
+        <param name='lglobal' doc='Library-internal global log family' />
+        <param name='llapd' doc='LAPD in libosmogsm' />
+        <param name='linp' doc='A-bis Intput Subsystem' />
+        <param name='lmux' doc='A-bis B-Subchannel TRAU Frame Multiplex' />
+        <param name='lmi' doc='A-bis Input Driver for Signalling' />
+        <param name='lmib' doc='A-bis Input Driver for B-Channels (voice)' />
+        <param name='lsms' doc='Layer3 Short Message Service (SMS)' />
+        <param name='lctrl' doc='Control Interface' />
+        <param name='lgtp' doc='GPRS GTP library' />
+        <param name='lstats' doc='Statistics messages and logging' />
+        <param name='lgsup' doc='Generic Subscriber Update Protocol' />
+        <param name='loap' doc='Osmocom Authentication Protocol' />
+        <param name='lss7' doc='libosmo-sigtran Signalling System 7' />
+        <param name='lsccp' doc='libosmo-sigtran SCCP Implementation' />
+        <param name='lsua' doc='libosmo-sigtran SCCP User Adaptation' />
+        <param name='lm3ua' doc='libosmo-sigtran MTP3 User Adaptation' />
+        <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
+        <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
+        <param name='everything' doc='Don&apos;t use. It doesn&apos;t log anything' />
+        <param name='debug' doc='Log debug messages and higher levels' />
+        <param name='info' doc='Log informational messages and higher levels' />
+        <param name='notice' doc='Log noticeable messages and higher levels' />
+        <param name='error' doc='Log error messages and higher levels' />
+        <param name='fatal' doc='Log only fatal messages' />
+      </params>
+    </command>
+    <command id='show logging vty'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='logging' doc='Show current logging configuration' />
+        <param name='vty' doc='Show current logging configuration for this vty' />
+      </params>
+    </command>
+    <command id='show alarms'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='alarms' doc='Show current logging configuration' />
+      </params>
+    </command>
+    <command id='show talloc-context (application|all) (full|brief|DEPTH)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='talloc-context' doc='Show talloc memory hierarchy' />
+        <param name='application' doc='Application&apos;s context' />
+        <param name='all' doc='All contexts, if NULL-context tracking is enabled' />
+        <param name='full' doc='Display a full talloc memory hierarchy' />
+        <param name='brief' doc='Display a brief talloc memory hierarchy' />
+        <param name='DEPTH' doc='Specify required maximal depth value' />
+      </params>
+    </command>
+    <command id='show talloc-context (application|all) (full|brief|DEPTH) tree ADDRESS'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='talloc-context' doc='Show talloc memory hierarchy' />
+        <param name='application' doc='Application&apos;s context' />
+        <param name='all' doc='All contexts, if NULL-context tracking is enabled' />
+        <param name='full' doc='Display a full talloc memory hierarchy' />
+        <param name='brief' doc='Display a brief talloc memory hierarchy' />
+        <param name='DEPTH' doc='Specify required maximal depth value' />
+        <param name='tree' doc='Display only a specific memory chunk' />
+        <param name='ADDRESS' doc='Chunk address (e.g. 0xdeadbeef)' />
+      </params>
+    </command>
+    <command id='show talloc-context (application|all) (full|brief|DEPTH) filter REGEXP'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='talloc-context' doc='Show talloc memory hierarchy' />
+        <param name='application' doc='Application&apos;s context' />
+        <param name='all' doc='All contexts, if NULL-context tracking is enabled' />
+        <param name='full' doc='Display a full talloc memory hierarchy' />
+        <param name='brief' doc='Display a brief talloc memory hierarchy' />
+        <param name='DEPTH' doc='Specify required maximal depth value' />
+        <param name='filter' doc='Filter chunks using regular expression' />
+        <param name='REGEXP' doc='Regular expression' />
+      </params>
+    </command>
+    <command id='show stats'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='stats' doc='Show statistical values' />
+      </params>
+    </command>
+    <command id='show stats level (global|peer|subscriber)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='stats' doc='Show statistical values' />
+        <param name='level' doc='Set the maximum group level' />
+        <param name='global' doc='Show global groups only' />
+        <param name='peer' doc='Show global and network peer related groups' />
+        <param name='subscriber' doc='Show global, peer, and subscriber groups' />
+      </params>
+    </command>
+    <command id='show asciidoc counters'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='asciidoc' doc='Asciidoc generation' />
+        <param name='counters' doc='Generate table of all registered counters' />
+      </params>
+    </command>
+    <command id='show sgsn'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='sgsn' doc='Display information about the SGSN' />
+      </params>
+    </command>
+    <command id='show mm-context imsi IMSI [pdp]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='mm-context' doc='MM Context' />
+        <param name='imsi' doc='Identify by IMSI' />
+        <param name='IMSI' doc='IMSI of the MM Context' />
+        <param name='[pdp]' doc='Include PDP Context Information' />
+      </params>
+    </command>
+    <command id='show mm-context all [pdp]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='mm-context' doc='MM Context' />
+        <param name='all' doc='All MM Contexts' />
+        <param name='[pdp]' doc='Include PDP Context Information' />
+      </params>
+    </command>
+    <command id='show pdp-context all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='pdp-context' doc='Display information on PDP Context' />
+        <param name='all' doc='Show everything' />
+      </params>
+    </command>
+    <command id='show subscriber cache'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='subscriber' doc='Show information about subscribers' />
+        <param name='cache' doc='Display contents of subscriber cache' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; users'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='users' doc='User Table' />
+      </params>
+    </command>
+    <command id='show cs7 (sua|m3ua|ipa) [&lt;0-65534&gt;]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='sua' doc='SCCP User Adaptation' />
+        <param name='m3ua' doc='MTP3 User Adaptation' />
+        <param name='ipa' doc='IPA Multiplex (SCCP Lite)' />
+        <param name='[&lt;0-65534&gt;]' doc='Port Number' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; asp'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='asp' doc='Application Server Process (ASP)' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; as (active|all|m3ua|sua)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='as' doc='Application Server (AS)' />
+        <param name='active' doc='Display all active ASs' />
+        <param name='all' doc='Display all ASs (default)' />
+        <param name='m3ua' doc='Display all m3ua ASs' />
+        <param name='sua' doc='Display all SUA ASs' />
+      </params>
+    </command>
+    <command id='show ns'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+      </params>
+    </command>
+    <command id='show ns stats'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='stats' doc='Include statistics' />
+      </params>
+    </command>
+    <command id='show ns persistent'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='persistent' doc='Show only persistent NS' />
+      </params>
+    </command>
+    <command id='show ns (nsei|nsvc) &lt;0-65535&gt; [stats]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='nsei' doc='Select one NSE by its NSE Identifier' />
+        <param name='nsvc' doc='Select one NSE by its NS-VC Identifier' />
+        <param name='&lt;0-65535&gt;' doc='The Identifier of selected type' />
+        <param name='[stats]' doc='Include Statistics' />
+      </params>
+    </command>
+    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='nsvc' doc='Filter based on NS Virtual Connection' />
+        <param name='nsei' doc='Identify NS-VC by NSEI' />
+        <param name='nsvci' doc='Identify NS-VC by NSVCI' />
+        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
+      </params>
+    </command>
+    <command id='show bssgp'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='bssgp' doc='Show information about the BSSGP protocol' />
+      </params>
+    </command>
+    <command id='show bssgp stats'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='bssgp' doc='Show information about the BSSGP protocol' />
+        <param name='stats' doc='Include statistics' />
+      </params>
+    </command>
+    <command id='show bssgp nsei &lt;0-65535&gt; [stats]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='bssgp' doc='Show information about the BSSGP protocol' />
+        <param name='nsei' doc='Show all BVCs on one NSE' />
+        <param name='&lt;0-65535&gt;' doc='The NSEI' />
+        <param name='[stats]' doc='Include Statistics' />
+      </params>
+    </command>
+    <command id='logging filter bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt;'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
+        <param name='nsei' doc='NSEI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
+        <param name='bvci' doc='BVCI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
+      </params>
+    </command>
+    <command id='bssgp bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt; reset'>
+      <params>
+        <param name='bssgp' doc='Initiate BVC RESET procedure for a given NSEI and BVCI' />
+        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
+        <param name='nsei' doc='NSEI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
+        <param name='bvci' doc='BVCI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
+        <param name='reset' doc='Perform reset procedure' />
+      </params>
+    </command>
+    <command id='show llc'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='llc' doc='Display information about the LLC protocol' />
+      </params>
+    </command>
+    <command id='show sndcp'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='sndcp' doc='Display information about the SNDCP protocol' />
+      </params>
+    </command>
+  </node>
+  <node id='enable'>
+    <name>enable</name>
+    <command id='disable'>
+      <params>
+        <param name='disable' doc='Turn off privileged mode command' />
+      </params>
+    </command>
+    <command id='configure terminal'>
+      <params>
+        <param name='configure' doc='Configuration from vty interface' />
+        <param name='terminal' doc='Configuration terminal' />
+      </params>
+    </command>
+    <command id='copy running-config startup-config'>
+      <params>
+        <param name='copy' doc='Copy configuration' />
+        <param name='running-config' doc='Copy running config to... ' />
+        <param name='startup-config' doc='Copy running config to startup config (same as write file)' />
+      </params>
+    </command>
+    <command id='show startup-config'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='startup-config' doc='Contentes of startup configuration' />
+      </params>
+    </command>
+    <command id='show version'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='version' doc='Displays program version' />
+      </params>
+    </command>
+    <command id='show online-help'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='online-help' doc='Online help' />
+      </params>
+    </command>
+    <command id='terminal length &lt;0-512&gt;'>
+      <params>
+        <param name='terminal' doc='Set terminal line parameters' />
+        <param name='length' doc='Set number of lines on a screen' />
+        <param name='&lt;0-512&gt;' doc='Number of lines on screen (0 for no pausing)' />
+      </params>
+    </command>
+    <command id='terminal no length'>
+      <params>
+        <param name='terminal' doc='Set terminal line parameters' />
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='length' doc='Set number of lines on a screen' />
+      </params>
+    </command>
+    <command id='echo .MESSAGE'>
+      <params>
+        <param name='echo' doc='Echo a message back to the vty' />
+        <param name='.MESSAGE' doc='The message to echo' />
+      </params>
+    </command>
+    <command id='who'>
+      <params>
+        <param name='who' doc='Display who is on vty' />
+      </params>
+    </command>
+    <command id='show history'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='history' doc='Display the session command history' />
+      </params>
+    </command>
+    <command id='terminal monitor'>
+      <params>
+        <param name='terminal' doc='Set terminal line parameters' />
+        <param name='monitor' doc='Copy debug output to the current terminal line' />
+      </params>
+    </command>
+    <command id='terminal no monitor'>
+      <params>
+        <param name='terminal' doc='Set terminal line parameters' />
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='monitor' doc='Copy debug output to the current terminal line' />
+      </params>
+    </command>
+    <command id='logging enable'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='enable' doc='Enables logging to this vty' />
+      </params>
+    </command>
+    <command id='logging disable'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='disable' doc='Disables logging to this vty' />
+      </params>
+    </command>
+    <command id='logging filter all (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='all' doc='Do you want to log all messages?' />
+        <param name='0' doc='Only print messages matched by other filters' />
+        <param name='1' doc='Bypass filter and print all messages' />
+      </params>
+    </command>
+    <command id='logging color (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='color' doc='Configure color-printing for log messages' />
+        <param name='0' doc='Don&apos;t use color for printing messages' />
+        <param name='1' doc='Use color for printing messages' />
+      </params>
+    </command>
+    <command id='logging timestamp (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='timestamp' doc='Configure log message timestamping' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with current timestamp' />
+      </params>
+    </command>
+    <command id='logging print extended-timestamp (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='extended-timestamp' doc='Configure log message timestamping' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with current timestamp with YYYYMMDDhhmmssnnn' />
+      </params>
+    </command>
+    <command id='logging print category (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='category' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with category/subsystem name' />
+      </params>
+    </command>
+    <command id='logging print category-hex (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='category-hex' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with category/subsystem nr in hex (&apos;&lt;000b&gt;&apos;)' />
+      </params>
+    </command>
+    <command id='logging print level (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='level' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with the log level name' />
+      </params>
+    </command>
+    <command id='logging print file (0|1|basename)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='file' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with the source file and line' />
+        <param name='basename' doc='Prefix each log message with the source file&apos;s basename (strip leading paths) and line' />
+      </params>
+    </command>
+    <command id='logging set-log-mask MASK'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='set-log-mask' doc='Set the logmask of this logging target' />
+        <param name='MASK' doc='List of logging categories to log, e.g. &apos;abc:mno:xyz&apos;. Available log categories depend on the specific application, refer to the &apos;logging level&apos; command. Optionally add individual log levels like &apos;abc,1:mno,3:xyz,5&apos;, where the level numbers are LOGL_DEBUG=1 LOGL_INFO=3 LOGL_NOTICE=5 LOGL_ERROR=7 LOGL_FATAL=8' />
+      </params>
+    </command>
+    <command id='logging set log mask MASK'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='set' doc='Decide which categories to output.' />
+        <param name='log' doc='Log commands' />
+        <param name='mask' doc='Mask commands' />
+        <param name='MASK' doc='&apos;set log mask&apos; is deprecated, please refer to the docs of &apos;set-log-mask&apos; instead' />
+      </params>
+    </command>
+    <command id='logging level (all|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf) (everything|debug|info|notice|error|fatal)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='level' doc='Set the log level for a specified category' />
+        <param name='all' doc='Global setting for all subsystems' />
+        <param name='mm' doc='Layer3 Mobility Management (MM)' />
+        <param name='pag' doc='Paging Subsystem' />
+        <param name='meas' doc='Radio Measurement Processing' />
+        <param name='ref' doc='Reference Counting' />
+        <param name='gprs' doc='GPRS Packet Service' />
+        <param name='ns' doc='GPRS Network Service (NS)' />
+        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
+        <param name='llc' doc='GPRS Logical Link Control Protocol (LLC)' />
+        <param name='sndcp' doc='GPRS Sub-Network Dependent Control Protocol (SNDCP)' />
+        <param name='slhc' doc='RFC1144 TCP/IP Header compression (SLHC)' />
+        <param name='ranap' doc='RAN Application Part (RANAP)' />
+        <param name='sua' doc='SCCP User Adaptation (SUA)' />
+        <param name='v42bis' doc='V.42bis data compression (SNDCP)' />
+        <param name='lglobal' doc='Library-internal global log family' />
+        <param name='llapd' doc='LAPD in libosmogsm' />
+        <param name='linp' doc='A-bis Intput Subsystem' />
+        <param name='lmux' doc='A-bis B-Subchannel TRAU Frame Multiplex' />
+        <param name='lmi' doc='A-bis Input Driver for Signalling' />
+        <param name='lmib' doc='A-bis Input Driver for B-Channels (voice)' />
+        <param name='lsms' doc='Layer3 Short Message Service (SMS)' />
+        <param name='lctrl' doc='Control Interface' />
+        <param name='lgtp' doc='GPRS GTP library' />
+        <param name='lstats' doc='Statistics messages and logging' />
+        <param name='lgsup' doc='Generic Subscriber Update Protocol' />
+        <param name='loap' doc='Osmocom Authentication Protocol' />
+        <param name='lss7' doc='libosmo-sigtran Signalling System 7' />
+        <param name='lsccp' doc='libosmo-sigtran SCCP Implementation' />
+        <param name='lsua' doc='libosmo-sigtran SCCP User Adaptation' />
+        <param name='lm3ua' doc='libosmo-sigtran MTP3 User Adaptation' />
+        <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
+        <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
+        <param name='everything' doc='Don&apos;t use. It doesn&apos;t log anything' />
+        <param name='debug' doc='Log debug messages and higher levels' />
+        <param name='info' doc='Log informational messages and higher levels' />
+        <param name='notice' doc='Log noticeable messages and higher levels' />
+        <param name='error' doc='Log error messages and higher levels' />
+        <param name='fatal' doc='Log only fatal messages' />
+      </params>
+    </command>
+    <command id='show logging vty'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='logging' doc='Show current logging configuration' />
+        <param name='vty' doc='Show current logging configuration for this vty' />
+      </params>
+    </command>
+    <command id='show alarms'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='alarms' doc='Show current logging configuration' />
+      </params>
+    </command>
+    <command id='show talloc-context (application|all) (full|brief|DEPTH)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='talloc-context' doc='Show talloc memory hierarchy' />
+        <param name='application' doc='Application&apos;s context' />
+        <param name='all' doc='All contexts, if NULL-context tracking is enabled' />
+        <param name='full' doc='Display a full talloc memory hierarchy' />
+        <param name='brief' doc='Display a brief talloc memory hierarchy' />
+        <param name='DEPTH' doc='Specify required maximal depth value' />
+      </params>
+    </command>
+    <command id='show talloc-context (application|all) (full|brief|DEPTH) tree ADDRESS'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='talloc-context' doc='Show talloc memory hierarchy' />
+        <param name='application' doc='Application&apos;s context' />
+        <param name='all' doc='All contexts, if NULL-context tracking is enabled' />
+        <param name='full' doc='Display a full talloc memory hierarchy' />
+        <param name='brief' doc='Display a brief talloc memory hierarchy' />
+        <param name='DEPTH' doc='Specify required maximal depth value' />
+        <param name='tree' doc='Display only a specific memory chunk' />
+        <param name='ADDRESS' doc='Chunk address (e.g. 0xdeadbeef)' />
+      </params>
+    </command>
+    <command id='show talloc-context (application|all) (full|brief|DEPTH) filter REGEXP'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='talloc-context' doc='Show talloc memory hierarchy' />
+        <param name='application' doc='Application&apos;s context' />
+        <param name='all' doc='All contexts, if NULL-context tracking is enabled' />
+        <param name='full' doc='Display a full talloc memory hierarchy' />
+        <param name='brief' doc='Display a brief talloc memory hierarchy' />
+        <param name='DEPTH' doc='Specify required maximal depth value' />
+        <param name='filter' doc='Filter chunks using regular expression' />
+        <param name='REGEXP' doc='Regular expression' />
+      </params>
+    </command>
+    <command id='show stats'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='stats' doc='Show statistical values' />
+      </params>
+    </command>
+    <command id='show stats level (global|peer|subscriber)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='stats' doc='Show statistical values' />
+        <param name='level' doc='Set the maximum group level' />
+        <param name='global' doc='Show global groups only' />
+        <param name='peer' doc='Show global and network peer related groups' />
+        <param name='subscriber' doc='Show global, peer, and subscriber groups' />
+      </params>
+    </command>
+    <command id='show asciidoc counters'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='asciidoc' doc='Asciidoc generation' />
+        <param name='counters' doc='Generate table of all registered counters' />
+      </params>
+    </command>
+    <command id='show sgsn'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='sgsn' doc='Display information about the SGSN' />
+      </params>
+    </command>
+    <command id='show mm-context imsi IMSI [pdp]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='mm-context' doc='MM Context' />
+        <param name='imsi' doc='Identify by IMSI' />
+        <param name='IMSI' doc='IMSI of the MM Context' />
+        <param name='[pdp]' doc='Include PDP Context Information' />
+      </params>
+    </command>
+    <command id='show mm-context all [pdp]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='mm-context' doc='MM Context' />
+        <param name='all' doc='All MM Contexts' />
+        <param name='[pdp]' doc='Include PDP Context Information' />
+      </params>
+    </command>
+    <command id='show pdp-context all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='pdp-context' doc='Display information on PDP Context' />
+        <param name='all' doc='Show everything' />
+      </params>
+    </command>
+    <command id='show subscriber cache'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='subscriber' doc='Show information about subscribers' />
+        <param name='cache' doc='Display contents of subscriber cache' />
+      </params>
+    </command>
+    <command id='update-subscriber imsi IMSI insert auth-triplet &lt;1-5&gt; sres SRES rand RAND kc KC'>
+      <params>
+        <param name='update-subscriber' doc='Update subscriber list' />
+        <param name='imsi' doc='Use the IMSI to select the subscriber' />
+        <param name='IMSI' doc='The IMSI' />
+        <param name='insert' doc='Insert data into the subscriber record' />
+        <param name='auth-triplet' doc='Update authentication triplet' />
+        <param name='&lt;1-5&gt;' doc='Triplet index' />
+        <param name='sres' doc='Set SRES value' />
+        <param name='SRES' doc='SRES value (4 byte) in hex' />
+        <param name='rand' doc='Set RAND value' />
+        <param name='RAND' doc='RAND value (16 byte) in hex' />
+        <param name='kc' doc='Set Kc value' />
+        <param name='KC' doc='Kc value (8 byte) in hex' />
+      </params>
+    </command>
+    <command id='update-subscriber imsi IMSI create'>
+      <params>
+        <param name='update-subscriber' doc='Update subscriber list' />
+        <param name='imsi' doc='Use the IMSI to select the subscriber' />
+        <param name='IMSI' doc='The IMSI' />
+        <param name='create' doc='Create a subscriber entry' />
+      </params>
+    </command>
+    <command id='update-subscriber imsi IMSI destroy'>
+      <params>
+        <param name='update-subscriber' doc='Update subscriber list' />
+        <param name='imsi' doc='Use the IMSI to select the subscriber' />
+        <param name='IMSI' doc='The IMSI' />
+        <param name='destroy' doc='Destroy a subscriber entry' />
+      </params>
+    </command>
+    <command id='update-subscriber imsi IMSI cancel (update-procedure|subscription-withdraw)'>
+      <params>
+        <param name='update-subscriber' doc='Update subscriber list' />
+        <param name='imsi' doc='Use the IMSI to select the subscriber' />
+        <param name='IMSI' doc='The IMSI' />
+        <param name='cancel' doc='Cancel (remove) subscriber record' />
+        <param name='update-procedure' doc='The MS moved to another SGSN' />
+        <param name='subscription-withdraw' doc='The subscription is no longer valid' />
+      </params>
+    </command>
+    <command id='update-subscriber imsi IMSI update-location-result (ok|system-failure|data-missing|unexpected-data-value|unknown-subscriber|roaming-not-allowed)'>
+      <params>
+        <param name='update-subscriber' doc='Update subscriber list' />
+        <param name='imsi' doc='Use the IMSI to select the subscriber' />
+        <param name='IMSI' doc='The IMSI' />
+        <param name='update-location-result' doc='Complete the update location procedure' />
+        <param name='ok' doc='The update location request succeeded' />
+        <param name='system-failure' doc='Force error code SystemFailure' />
+        <param name='data-missing' doc='Force error code DataMissing' />
+        <param name='unexpected-data-value' doc='Force error code UnexpectedDataValue' />
+        <param name='unknown-subscriber' doc='Force error code UnknownSubscriber' />
+        <param name='roaming-not-allowed' doc='Force error code RoamingNotAllowed' />
+      </params>
+    </command>
+    <command id='update-subscriber imsi IMSI update-auth-info'>
+      <params>
+        <param name='update-subscriber' doc='Update subscriber list' />
+        <param name='imsi' doc='Use the IMSI to select the subscriber' />
+        <param name='IMSI' doc='The IMSI' />
+        <param name='update-auth-info' doc='Complete the send authentication info procedure' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; users'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='users' doc='User Table' />
+      </params>
+    </command>
+    <command id='show cs7 (sua|m3ua|ipa) [&lt;0-65534&gt;]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='sua' doc='SCCP User Adaptation' />
+        <param name='m3ua' doc='MTP3 User Adaptation' />
+        <param name='ipa' doc='IPA Multiplex (SCCP Lite)' />
+        <param name='[&lt;0-65534&gt;]' doc='Port Number' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; asp'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='asp' doc='Application Server Process (ASP)' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; as (active|all|m3ua|sua)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='as' doc='Application Server (AS)' />
+        <param name='active' doc='Display all active ASs' />
+        <param name='all' doc='Display all ASs (default)' />
+        <param name='m3ua' doc='Display all m3ua ASs' />
+        <param name='sua' doc='Display all SUA ASs' />
+      </params>
+    </command>
+    <command id='show ns'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+      </params>
+    </command>
+    <command id='show ns stats'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='stats' doc='Include statistics' />
+      </params>
+    </command>
+    <command id='show ns persistent'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='persistent' doc='Show only persistent NS' />
+      </params>
+    </command>
+    <command id='show ns (nsei|nsvc) &lt;0-65535&gt; [stats]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='nsei' doc='Select one NSE by its NSE Identifier' />
+        <param name='nsvc' doc='Select one NSE by its NS-VC Identifier' />
+        <param name='&lt;0-65535&gt;' doc='The Identifier of selected type' />
+        <param name='[stats]' doc='Include Statistics' />
+      </params>
+    </command>
+    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='nsvc' doc='Filter based on NS Virtual Connection' />
+        <param name='nsei' doc='Identify NS-VC by NSEI' />
+        <param name='nsvci' doc='Identify NS-VC by NSVCI' />
+        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
+      </params>
+    </command>
+    <command id='nsvc (nsei|nsvci) &lt;0-65535&gt; (block|unblock|reset)'>
+      <params>
+        <param name='nsvc' doc='Perform an operation on a NSVC' />
+        <param name='nsei' doc='NSEI to identify NS-VC Identifier (NS-VCI)' />
+        <param name='nsvci' doc='NS-VC Identifier (NS-VCI)' />
+        <param name='&lt;0-65535&gt;' doc='The NSEI' />
+        <param name='block' doc='Initiate BLOCK procedure' />
+        <param name='unblock' doc='Initiate UNBLOCK procedure' />
+        <param name='reset' doc='Initiate RESET procedure' />
+      </params>
+    </command>
+    <command id='show bssgp'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='bssgp' doc='Show information about the BSSGP protocol' />
+      </params>
+    </command>
+    <command id='show bssgp stats'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='bssgp' doc='Show information about the BSSGP protocol' />
+        <param name='stats' doc='Include statistics' />
+      </params>
+    </command>
+    <command id='show bssgp nsei &lt;0-65535&gt; [stats]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='bssgp' doc='Show information about the BSSGP protocol' />
+        <param name='nsei' doc='Show all BVCs on one NSE' />
+        <param name='&lt;0-65535&gt;' doc='The NSEI' />
+        <param name='[stats]' doc='Include Statistics' />
+      </params>
+    </command>
+    <command id='logging filter bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt;'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
+        <param name='nsei' doc='NSEI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
+        <param name='bvci' doc='BVCI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
+      </params>
+    </command>
+    <command id='bssgp bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt; reset'>
+      <params>
+        <param name='bssgp' doc='Initiate BVC RESET procedure for a given NSEI and BVCI' />
+        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
+        <param name='nsei' doc='NSEI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
+        <param name='bvci' doc='BVCI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
+        <param name='reset' doc='Perform reset procedure' />
+      </params>
+    </command>
+    <command id='show llc'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='llc' doc='Display information about the LLC protocol' />
+      </params>
+    </command>
+    <command id='show sndcp'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='sndcp' doc='Display information about the SNDCP protocol' />
+      </params>
+    </command>
+  </node>
+  <node id='config'>
+    <name>config</name>
+    <command id='hostname WORD'>
+      <params>
+        <param name='hostname' doc='Set system&apos;s network name' />
+        <param name='WORD' doc='This system&apos;s network name' />
+      </params>
+    </command>
+    <command id='no hostname [HOSTNAME]'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='hostname' doc='Reset system&apos;s network name' />
+        <param name='[HOSTNAME]' doc='Host name of this router' />
+      </params>
+    </command>
+    <command id='password (8|) WORD'>
+      <params>
+        <param name='password' doc='Assign the terminal connection password' />
+        <param name='8' doc='Specifies a HIDDEN password will follow' />
+        <param name='' doc='dummy string ' />
+        <param name='WORD' doc='The HIDDEN line password string' />
+      </params>
+    </command>
+    <command id='password LINE'>
+      <params>
+        <param name='password' doc='Assign the terminal connection password' />
+        <param name='LINE' doc='The UNENCRYPTED (cleartext) line password' />
+      </params>
+    </command>
+    <command id='enable password (8|) WORD'>
+      <params>
+        <param name='enable' doc='Modify enable password parameters' />
+        <param name='password' doc='Assign the privileged level password' />
+        <param name='8' doc='Specifies a HIDDEN password will follow' />
+        <param name='' doc='dummy string ' />
+        <param name='WORD' doc='The HIDDEN &apos;enable&apos; password string' />
+      </params>
+    </command>
+    <command id='enable password LINE'>
+      <params>
+        <param name='enable' doc='Modify enable password parameters' />
+        <param name='password' doc='Assign the privileged level password' />
+        <param name='LINE' doc='The UNENCRYPTED (cleartext) &apos;enable&apos; password' />
+      </params>
+    </command>
+    <command id='no enable password'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='enable' doc='Modify enable password parameters' />
+        <param name='password' doc='Assign the privileged level password' />
+      </params>
+    </command>
+    <command id='banner motd default'>
+      <params>
+        <param name='banner' doc='Set banner string' />
+        <param name='motd' doc='Strings for motd' />
+        <param name='default' doc='Default string' />
+      </params>
+    </command>
+    <command id='banner motd file [FILE]'>
+      <params>
+        <param name='banner' doc='Set banner' />
+        <param name='motd' doc='Banner for motd' />
+        <param name='file' doc='Banner from a file' />
+        <param name='[FILE]' doc='Filename' />
+      </params>
+    </command>
+    <command id='no banner motd'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='banner' doc='Set banner string' />
+        <param name='motd' doc='Strings for motd' />
+      </params>
+    </command>
+    <command id='service terminal-length &lt;0-512&gt;'>
+      <params>
+        <param name='service' doc='Set up miscellaneous service' />
+        <param name='terminal-length' doc='System wide terminal length configuration' />
+        <param name='&lt;0-512&gt;' doc='Number of lines of VTY (0 means no line control)' />
+      </params>
+    </command>
+    <command id='no service terminal-length [&lt;0-512&gt;]'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='service' doc='Set up miscellaneous service' />
+        <param name='terminal-length' doc='System wide terminal length configuration' />
+        <param name='[&lt;0-512&gt;]' doc='Number of lines of VTY (0 means no line control)' />
+      </params>
+    </command>
+    <command id='line vty'>
+      <params>
+        <param name='line' doc='Configure a terminal line' />
+        <param name='vty' doc='Virtual terminal' />
+      </params>
+    </command>
+    <command id='service advanced-vty'>
+      <params>
+        <param name='service' doc='Set up miscellaneous service' />
+        <param name='advanced-vty' doc='Enable advanced mode vty interface' />
+      </params>
+    </command>
+    <command id='no service advanced-vty'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='service' doc='Set up miscellaneous service' />
+        <param name='advanced-vty' doc='Enable advanced mode vty interface' />
+      </params>
+    </command>
+    <command id='show history'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='history' doc='Display the session command history' />
+      </params>
+    </command>
+    <command id='log stderr'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='stderr' doc='Logging via STDERR of the process' />
+      </params>
+    </command>
+    <command id='no log stderr'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='stderr' doc='Logging via STDERR of the process' />
+      </params>
+    </command>
+    <command id='log file .FILENAME'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='file' doc='Logging to text file' />
+        <param name='.FILENAME' doc='Filename' />
+      </params>
+    </command>
+    <command id='no log file .FILENAME'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='file' doc='Logging to text file' />
+        <param name='.FILENAME' doc='Filename' />
+      </params>
+    </command>
+    <command id='log alarms &lt;2-32700&gt;'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='alarms' doc='Logging alarms to osmo_strrb' />
+        <param name='&lt;2-32700&gt;' doc='Maximum number of messages to log' />
+      </params>
+    </command>
+    <command id='no log alarms'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='alarms' doc='Logging alarms to osmo_strrb' />
+      </params>
+    </command>
+    <command id='log syslog (authpriv|cron|daemon|ftp|lpr|mail|news|user|uucp)'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='syslog' doc='Logging via syslog' />
+        <param name='authpriv' doc='Security/authorization messages facility' />
+        <param name='cron' doc='Clock daemon (cron/at) facility' />
+        <param name='daemon' doc='General system daemon facility' />
+        <param name='ftp' doc='Ftp daemon facility' />
+        <param name='lpr' doc='Line printer facility' />
+        <param name='mail' doc='Mail facility' />
+        <param name='news' doc='News facility' />
+        <param name='user' doc='Generic facility' />
+        <param name='uucp' doc='UUCP facility' />
+      </params>
+    </command>
+    <command id='log syslog local &lt;0-7&gt;'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='syslog' doc='Logging via syslog' />
+        <param name='local' doc='Syslog LOCAL facility' />
+        <param name='&lt;0-7&gt;' doc='Local facility number' />
+      </params>
+    </command>
+    <command id='no log syslog'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='syslog' doc='Logging via syslog' />
+      </params>
+    </command>
+    <command id='log gsmtap [HOSTNAME]'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='gsmtap' doc='Logging via GSMTAP' />
+        <param name='[HOSTNAME]' doc='Host name to send the GSMTAP logging to (UDP port 4729)' />
+      </params>
+    </command>
+    <command id='stats reporter statsd'>
+      <params>
+        <param name='stats' doc='Configure stats sub-system' />
+        <param name='reporter' doc='Configure a stats reporter' />
+        <param name='statsd' doc='Report to a STATSD server' />
+      </params>
+    </command>
+    <command id='no stats reporter statsd'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='stats' doc='Configure stats sub-system' />
+        <param name='reporter' doc='Configure a stats reporter' />
+        <param name='statsd' doc='Report to a STATSD server' />
+      </params>
+    </command>
+    <command id='stats reporter log'>
+      <params>
+        <param name='stats' doc='Configure stats sub-system' />
+        <param name='reporter' doc='Configure a stats reporter' />
+        <param name='log' doc='Report to the logger' />
+      </params>
+    </command>
+    <command id='no stats reporter log'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='stats' doc='Configure stats sub-system' />
+        <param name='reporter' doc='Configure a stats reporter' />
+        <param name='log' doc='Report to the logger' />
+      </params>
+    </command>
+    <command id='stats interval &lt;1-65535&gt;'>
+      <params>
+        <param name='stats' doc='Configure stats sub-system' />
+        <param name='interval' doc='Set the reporting interval' />
+        <param name='&lt;1-65535&gt;' doc='Interval in seconds' />
+      </params>
+    </command>
+    <command id='sgsn'>
+      <params>
+        <param name='sgsn' doc='Configure the SGSN' />
+      </params>
+    </command>
+    <command id='ctrl'>
+      <params>
+        <param name='ctrl' doc='Configure the Control Interface' />
+      </params>
+    </command>
+    <command id='cs7 instance &lt;0-15&gt;'>
+      <params>
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='Configure a SS7 Instance' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+      </params>
+    </command>
+    <command id='ns'>
+      <params>
+        <param name='ns' doc='Configure the GPRS Network Service' />
+      </params>
+    </command>
+    <command id='bssgp'>
+      <params>
+        <param name='bssgp' doc='Configure the GPRS BSS Gateway Protocol' />
+      </params>
+    </command>
+  </node>
+  <node id='config-log'>
+    <name>config-log</name>
+    <command id='logging filter all (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='all' doc='Do you want to log all messages?' />
+        <param name='0' doc='Only print messages matched by other filters' />
+        <param name='1' doc='Bypass filter and print all messages' />
+      </params>
+    </command>
+    <command id='logging color (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='color' doc='Configure color-printing for log messages' />
+        <param name='0' doc='Don&apos;t use color for printing messages' />
+        <param name='1' doc='Use color for printing messages' />
+      </params>
+    </command>
+    <command id='logging timestamp (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='timestamp' doc='Configure log message timestamping' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with current timestamp' />
+      </params>
+    </command>
+    <command id='logging print extended-timestamp (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='extended-timestamp' doc='Configure log message timestamping' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with current timestamp with YYYYMMDDhhmmssnnn' />
+      </params>
+    </command>
+    <command id='logging print category (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='category' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with category/subsystem name' />
+      </params>
+    </command>
+    <command id='logging print category-hex (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='category-hex' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with category/subsystem nr in hex (&apos;&lt;000b&gt;&apos;)' />
+      </params>
+    </command>
+    <command id='logging print level (0|1)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='level' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with the log level name' />
+      </params>
+    </command>
+    <command id='logging print file (0|1|basename)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='print' doc='Log output settings' />
+        <param name='file' doc='Configure log message' />
+        <param name='0' doc='Don&apos;t prefix each log message' />
+        <param name='1' doc='Prefix each log message with the source file and line' />
+        <param name='basename' doc='Prefix each log message with the source file&apos;s basename (strip leading paths) and line' />
+      </params>
+    </command>
+    <command id='logging level (all|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf) (everything|debug|info|notice|error|fatal)'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='level' doc='Set the log level for a specified category' />
+        <param name='all' doc='Global setting for all subsystems' />
+        <param name='mm' doc='Layer3 Mobility Management (MM)' />
+        <param name='pag' doc='Paging Subsystem' />
+        <param name='meas' doc='Radio Measurement Processing' />
+        <param name='ref' doc='Reference Counting' />
+        <param name='gprs' doc='GPRS Packet Service' />
+        <param name='ns' doc='GPRS Network Service (NS)' />
+        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
+        <param name='llc' doc='GPRS Logical Link Control Protocol (LLC)' />
+        <param name='sndcp' doc='GPRS Sub-Network Dependent Control Protocol (SNDCP)' />
+        <param name='slhc' doc='RFC1144 TCP/IP Header compression (SLHC)' />
+        <param name='ranap' doc='RAN Application Part (RANAP)' />
+        <param name='sua' doc='SCCP User Adaptation (SUA)' />
+        <param name='v42bis' doc='V.42bis data compression (SNDCP)' />
+        <param name='lglobal' doc='Library-internal global log family' />
+        <param name='llapd' doc='LAPD in libosmogsm' />
+        <param name='linp' doc='A-bis Intput Subsystem' />
+        <param name='lmux' doc='A-bis B-Subchannel TRAU Frame Multiplex' />
+        <param name='lmi' doc='A-bis Input Driver for Signalling' />
+        <param name='lmib' doc='A-bis Input Driver for B-Channels (voice)' />
+        <param name='lsms' doc='Layer3 Short Message Service (SMS)' />
+        <param name='lctrl' doc='Control Interface' />
+        <param name='lgtp' doc='GPRS GTP library' />
+        <param name='lstats' doc='Statistics messages and logging' />
+        <param name='lgsup' doc='Generic Subscriber Update Protocol' />
+        <param name='loap' doc='Osmocom Authentication Protocol' />
+        <param name='lss7' doc='libosmo-sigtran Signalling System 7' />
+        <param name='lsccp' doc='libosmo-sigtran SCCP Implementation' />
+        <param name='lsua' doc='libosmo-sigtran SCCP User Adaptation' />
+        <param name='lm3ua' doc='libosmo-sigtran MTP3 User Adaptation' />
+        <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
+        <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
+        <param name='everything' doc='Don&apos;t use. It doesn&apos;t log anything' />
+        <param name='debug' doc='Log debug messages and higher levels' />
+        <param name='info' doc='Log informational messages and higher levels' />
+        <param name='notice' doc='Log noticeable messages and higher levels' />
+        <param name='error' doc='Log error messages and higher levels' />
+        <param name='fatal' doc='Log only fatal messages' />
+      </params>
+    </command>
+    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='nsvc' doc='Filter based on NS Virtual Connection' />
+        <param name='nsei' doc='Identify NS-VC by NSEI' />
+        <param name='nsvci' doc='Identify NS-VC by NSVCI' />
+        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
+      </params>
+    </command>
+    <command id='logging filter bvc nsei &lt;0-65535&gt; bvci &lt;0-65535&gt;'>
+      <params>
+        <param name='logging' doc='Configure logging' />
+        <param name='filter' doc='Filter log messages' />
+        <param name='bvc' doc='Filter based on BSSGP Virtual Connection' />
+        <param name='nsei' doc='NSEI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='Network Service Entity Identifier (NSEI)' />
+        <param name='bvci' doc='BVCI of the BVC to be filtered' />
+        <param name='&lt;0-65535&gt;' doc='BSSGP Virtual Connection Identifier (BVCI)' />
+      </params>
+    </command>
+  </node>
+  <node id='config-stats'>
+    <name>config-stats</name>
+    <command id='local-ip ADDR'>
+      <params>
+        <param name='local-ip' doc='Set the IP address to which we bind locally' />
+        <param name='ADDR' doc='IP Address' />
+      </params>
+    </command>
+    <command id='no local-ip'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='local-ip' doc='Set the IP address to which we bind locally' />
+      </params>
+    </command>
+    <command id='remote-ip ADDR'>
+      <params>
+        <param name='remote-ip' doc='Set the remote IP address to which we connect' />
+        <param name='ADDR' doc='IP Address' />
+      </params>
+    </command>
+    <command id='remote-port &lt;1-65535&gt;'>
+      <params>
+        <param name='remote-port' doc='Set the remote port to which we connect' />
+        <param name='&lt;1-65535&gt;' doc='Remote port number' />
+      </params>
+    </command>
+    <command id='mtu &lt;100-65535&gt;'>
+      <params>
+        <param name='mtu' doc='Set the maximum packet size' />
+        <param name='&lt;100-65535&gt;' doc='Size in byte' />
+      </params>
+    </command>
+    <command id='no mtu'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='mtu' doc='Set the maximum packet size' />
+      </params>
+    </command>
+    <command id='prefix PREFIX'>
+      <params>
+        <param name='prefix' doc='Set the item name prefix' />
+        <param name='PREFIX' doc='The prefix string' />
+      </params>
+    </command>
+    <command id='no prefix'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='prefix' doc='Set the item name prefix' />
+      </params>
+    </command>
+    <command id='level (global|peer|subscriber)'>
+      <params>
+        <param name='level' doc='Set the maximum group level' />
+        <param name='global' doc='Report global groups only' />
+        <param name='peer' doc='Report global and network peer related groups' />
+        <param name='subscriber' doc='Report global, peer, and subscriber groups' />
+      </params>
+    </command>
+    <command id='enable'>
+      <params>
+        <param name='enable' doc='Enable the reporter' />
+      </params>
+    </command>
+    <command id='disable'>
+      <params>
+        <param name='disable' doc='Disable the reporter' />
+      </params>
+    </command>
+  </node>
+  <node id='config-line'>
+    <name>config-line</name>
+    <command id='login'>
+      <params>
+        <param name='login' doc='Enable password checking' />
+      </params>
+    </command>
+    <command id='no login'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='login' doc='Enable password checking' />
+      </params>
+    </command>
+    <command id='bind A.B.C.D'>
+      <params>
+        <param name='bind' doc='Accept VTY telnet connections on local interface' />
+        <param name='A.B.C.D' doc='Local interface IP address (default: 127.0.0.1)' />
+      </params>
+    </command>
+  </node>
+  <node id='config-ns'>
+    <name>config-ns</name>
+    <command id='nse &lt;0-65535&gt; nsvci &lt;0-65534&gt;'>
+      <params>
+        <param name='nse' doc='Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+        <param name='nsvci' doc='NS Virtual Connection' />
+        <param name='&lt;0-65534&gt;' doc='NS Virtual Connection ID (NSVCI)' />
+      </params>
+    </command>
+    <command id='nse &lt;0-65535&gt; remote-ip A.B.C.D'>
+      <params>
+        <param name='nse' doc='Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+        <param name='remote-ip' doc='Remote IP Address' />
+        <param name='A.B.C.D' doc='Remote IP Address' />
+      </params>
+    </command>
+    <command id='nse &lt;0-65535&gt; remote-port &lt;0-65535&gt;'>
+      <params>
+        <param name='nse' doc='Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+        <param name='remote-port' doc='Remote UDP Port' />
+        <param name='&lt;0-65535&gt;' doc='Remote UDP Port Number' />
+      </params>
+    </command>
+    <command id='nse &lt;0-65535&gt; fr-dlci &lt;16-1007&gt;'>
+      <params>
+        <param name='nse' doc='Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+        <param name='fr-dlci' doc='Frame Relay DLCI' />
+        <param name='&lt;16-1007&gt;' doc='Frame Relay DLCI Number' />
+      </params>
+    </command>
+    <command id='nse &lt;0-65535&gt; encapsulation (udp|framerelay-gre)'>
+      <params>
+        <param name='nse' doc='Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+        <param name='encapsulation' doc='Encapsulation for NS' />
+        <param name='udp' doc='UDP/IP Encapsulation' />
+        <param name='framerelay-gre' doc='Frame-Relay/GRE/IP Encapsulation' />
+      </params>
+    </command>
+    <command id='nse &lt;0-65535&gt; remote-role (sgsn|bss)'>
+      <params>
+        <param name='nse' doc='Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+        <param name='remote-role' doc='Remote NSE Role' />
+        <param name='sgsn' doc='Remote Peer is SGSN' />
+        <param name='bss' doc='Remote Peer is BSS' />
+      </params>
+    </command>
+    <command id='no nse &lt;0-65535&gt;'>
+      <params>
+        <param name='no' doc='Delete Persistent NS Entity' />
+        <param name='nse' doc='Delete Persistent NS Entity' />
+        <param name='&lt;0-65535&gt;' doc='NS Entity ID (NSEI)' />
+      </params>
+    </command>
+    <command id='timer (tns-block|tns-block-retries|tns-reset|tns-reset-retries|tns-test|tns-alive|tns-alive-retries) &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Network Service Timer' />
+        <param name='tns-block' doc='(un)blocking Timer (Tns-block) timeout' />
+        <param name='tns-block-retries' doc='(un)blocking Timer (Tns-block) number of retries' />
+        <param name='tns-reset' doc='Reset Timer (Tns-reset) timeout' />
+        <param name='tns-reset-retries' doc='Reset Timer (Tns-reset) number of retries' />
+        <param name='tns-test' doc='Test Timer (Tns-test) timeout' />
+        <param name='tns-alive' doc='Alive Timer (Tns-alive) timeout' />
+        <param name='tns-alive-retries' doc='Alive Timer (Tns-alive) number of retries' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value' />
+      </params>
+    </command>
+    <command id='encapsulation udp local-ip A.B.C.D'>
+      <params>
+        <param name='encapsulation' doc='NS encapsulation options' />
+        <param name='udp' doc='NS over UDP Encapsulation' />
+        <param name='local-ip' doc='Set the IP address on which we listen for NS/UDP' />
+        <param name='A.B.C.D' doc='IP Address' />
+      </params>
+    </command>
+    <command id='encapsulation udp local-port &lt;0-65535&gt;'>
+      <params>
+        <param name='encapsulation' doc='NS encapsulation options' />
+        <param name='udp' doc='NS over UDP Encapsulation' />
+        <param name='local-port' doc='Set the UDP port on which we listen for NS/UDP' />
+        <param name='&lt;0-65535&gt;' doc='UDP port number' />
+      </params>
+    </command>
+    <command id='encapsulation udp dscp &lt;0-255&gt;'>
+      <params>
+        <param name='encapsulation' doc='NS encapsulation options' />
+        <param name='udp' doc='NS over UDP Encapsulation' />
+        <param name='dscp' doc='Set DSCP/TOS on the UDP socket' />
+        <param name='&lt;0-255&gt;' doc='DSCP Value' />
+      </params>
+    </command>
+    <command id='encapsulation framerelay-gre enabled (1|0)'>
+      <params>
+        <param name='encapsulation' doc='NS encapsulation options' />
+        <param name='framerelay-gre' doc='NS over Frame Relay over GRE Encapsulation' />
+        <param name='enabled' doc='Enable or disable Frame Relay over GRE' />
+        <param name='1' doc='Enable' />
+        <param name='0' doc='Disable' />
+      </params>
+    </command>
+    <command id='encapsulation framerelay-gre local-ip A.B.C.D'>
+      <params>
+        <param name='encapsulation' doc='NS encapsulation options' />
+        <param name='framerelay-gre' doc='NS over Frame Relay over GRE Encapsulation' />
+        <param name='local-ip' doc='Set the IP address on which we listen for NS/FR/GRE' />
+        <param name='A.B.C.D' doc='IP Address' />
+      </params>
+    </command>
+  </node>
+  <node id='config-bssgp'>
+    <name>config-bssgp</name>
+  </node>
+  <node id='config-ctrl'>
+    <name>config-ctrl</name>
+    <command id='bind A.B.C.D'>
+      <params>
+        <param name='bind' doc='Set bind address to listen for Control connections' />
+        <param name='A.B.C.D' doc='Local IP address (default 127.0.0.1)' />
+      </params>
+    </command>
+  </node>
+  <node id='config-cs7'>
+    <name>config-cs7</name>
+    <command id='description .TEXT'>
+      <params>
+        <param name='description' doc='Save human-readable description of the object' />
+        <param name='.TEXT' doc='Text until the end of the line' />
+      </params>
+    </command>
+    <command id='network-indicator (international | national | reserved | spare)'>
+      <params>
+        <param name='network-indicator' doc='Configure the Network Indicator' />
+        <param name='international' doc='International Network' />
+        <param name='national' doc='National Network' />
+        <param name='reserved' doc='Reserved Network' />
+        <param name='spare' doc='Spare Network' />
+      </params>
+    </command>
+    <command id='point-code POINT_CODE'>
+      <params>
+        <param name='point-code' doc='Configure the local Point Code' />
+        <param name='POINT_CODE' doc='Point Code' />
+      </params>
+    </command>
+    <command id='point-code format &lt;1-24&gt; [&lt;1-23&gt;] [&lt;1-22&gt;]'>
+      <params>
+        <param name='point-code' doc='Point Code' />
+        <param name='format' doc='Configure Point Code Format' />
+        <param name='&lt;1-24&gt;' doc='Length of first PC component' />
+        <param name='[&lt;1-23&gt;]' doc='Length of second PC component' />
+        <param name='[&lt;1-22&gt;]' doc='Length of third PC component' />
+      </params>
+    </command>
+    <command id='point-code format default'>
+      <params>
+        <param name='point-code' doc='Point Code' />
+        <param name='format' doc='Configure Point Code Format' />
+        <param name='default' doc='Default Point Code Format (3.8.3)' />
+      </params>
+    </command>
+    <command id='point-code delimiter (default|dash)'>
+      <params>
+        <param name='point-code' doc='Point Code' />
+        <param name='delimiter' doc='Configure Point Code Delimiter' />
+        <param name='default' doc='Use dot as delimiter' />
+        <param name='dash' doc='User dash as delimiter' />
+      </params>
+    </command>
+    <command id='xua rkm routing-key-allocation (static-only|dynamic-permitted)'>
+      <params>
+        <param name='xua' doc='SIGTRAN xxxUA related' />
+        <param name='rkm' doc='Routing Key Management' />
+        <param name='routing-key-allocation' doc='Routing Key Management Allocation Policy' />
+        <param name='static-only' doc='Only static (pre-confgured) Routing Keys permitted' />
+        <param name='dynamic-permitted' doc='Dynamically allocate Routing Keys for what ASPs request' />
+      </params>
+    </command>
+    <command id='asp NAME &lt;0-65535&gt; &lt;0-65535&gt; (sua|m3ua|ipa)'>
+      <params>
+        <param name='asp' doc='Configure Application Server Process' />
+        <param name='NAME' doc='Name of ASP' />
+        <param name='&lt;0-65535&gt;' doc='Remote SCTP port number' />
+        <param name='&lt;0-65535&gt;' doc='Local SCTP port number' />
+        <param name='sua' doc='SCCP User Adaptation' />
+        <param name='m3ua' doc='MTP3 User Adaptation' />
+        <param name='ipa' doc='IPA Multiplex (SCCP Lite)' />
+      </params>
+    </command>
+    <command id='no asp NAME'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='asp' doc='Disable Application Server Process' />
+        <param name='NAME' doc='Name of ASP' />
+      </params>
+    </command>
+    <command id='as NAME (sua|m3ua|ipa)'>
+      <params>
+        <param name='as' doc='Configure an Application Server' />
+        <param name='NAME' doc='Name of the Application Server' />
+        <param name='sua' doc='SCCP User Adaptation' />
+        <param name='m3ua' doc='MTP3 User Adaptation' />
+        <param name='ipa' doc='IPA Multiplex (SCCP Lite)' />
+      </params>
+    </command>
+    <command id='no as NAME'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='as' doc='Disable Application Server' />
+        <param name='NAME' doc='Name of AS' />
+      </params>
+    </command>
+    <command id='show cs7 instance &lt;0-15&gt; sccp-addressbook'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='cs7' doc='ITU-T Signaling System 7' />
+        <param name='instance' doc='An instance of the SS7 stack' />
+        <param name='&lt;0-15&gt;' doc='An instance of the SS7 stack' />
+        <param name='sccp-addressbook' doc='List all SCCP addressbook entries' />
+      </params>
+    </command>
+    <command id='sccp-address NAME'>
+      <params>
+        <param name='sccp-address' doc='Create/Modify an SCCP addressbook entry' />
+        <param name='NAME' doc='Name of the SCCP Address' />
+      </params>
+    </command>
+    <command id='no sccp-address NAME'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='sccp-address' doc='Delete an SCCP addressbook entry' />
+        <param name='NAME' doc='Name of the SCCP Address' />
+      </params>
+    </command>
+  </node>
+  <node id='config-cs7-as'>
+    <name>config-cs7-as</name>
+    <command id='description .TEXT'>
+      <params>
+        <param name='description' doc='Save human-readable description of the object' />
+        <param name='.TEXT' doc='Text until the end of the line' />
+      </params>
+    </command>
+    <command id='asp NAME'>
+      <params>
+        <param name='asp' doc='Specify that a given ASP is part of this AS' />
+        <param name='NAME' doc='Name of ASP to be added to AS' />
+      </params>
+    </command>
+    <command id='no asp NAME'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='asp' doc='Specify ASP to be removed from this AS' />
+        <param name='NAME' doc='Name of ASP to be removed' />
+      </params>
+    </command>
+    <command id='traffic-mode (broadcast | loadshare | roundrobin | override)'>
+      <params>
+        <param name='traffic-mode' doc='Specifies traffic mode of operation of the ASP within the AS' />
+        <param name='broadcast' doc='Broadcast to all ASP within AS' />
+        <param name='loadshare' doc='Share Load among all ASP within AS' />
+        <param name='roundrobin' doc='Round-Robin between all ASP within AS' />
+        <param name='override' doc='Override' />
+      </params>
+    </command>
+    <command id='recovery-timeout &lt;1-2000&gt;'>
+      <params>
+        <param name='recovery-timeout' doc='Specifies the recovery timeout value in milliseconds' />
+        <param name='&lt;1-2000&gt;' doc='Recovery Timeout in Milliseconds' />
+      </params>
+    </command>
+    <command id='qos-class &lt;0-255&gt;'>
+      <params>
+        <param name='qos-class' doc='Specity QoS Class of AS' />
+        <param name='&lt;0-255&gt;' doc='QoS Class of AS' />
+      </params>
+    </command>
+    <command id='routing-key RCONTEXT DPC'>
+      <params>
+        <param name='routing-key' doc='Define a routing key' />
+        <param name='RCONTEXT' doc='Routing context number' />
+        <param name='DPC' doc='Destination Point Code' />
+      </params>
+    </command>
+    <command id='routing-key RCONTEXT DPC si (aal2|bicc|b-isup|h248|isup|sat-isup|sccp|tup)'>
+      <params>
+        <param name='routing-key' doc='Define a routing key' />
+        <param name='RCONTEXT' doc='Routing context number' />
+        <param name='DPC' doc='Destination Point Code' />
+        <param name='si' doc='Match on Service Indicator' />
+        <param name='aal2' doc='ATM Adaption Layer 2' />
+        <param name='bicc' doc='Bearer Independent Call Control' />
+        <param name='b-isup' doc='Broadband ISDN User Part' />
+        <param name='h248' doc='H.248' />
+        <param name='isup' doc='ISDN User Part' />
+        <param name='sat-isup' doc='Sattelite ISDN User Part' />
+        <param name='sccp' doc='Signalling Connection Control Part' />
+        <param name='tup' doc='Telephony User Part' />
+      </params>
+    </command>
+    <command id='routing-key RCONTEXT DPC ssn SSN'>
+      <params>
+        <param name='routing-key' doc='Define a routing key' />
+        <param name='RCONTEXT' doc='Routing context number' />
+        <param name='DPC' doc='Destination Point Code' />
+        <param name='ssn' doc='Match on Sub-System Number' />
+        <param name='SSN' doc='Sub-System Number to match on' />
+      </params>
+    </command>
+    <command id='routing-key RCONTEXT DPC si (aal2|bicc|b-isup|h248|isup|sat-isup|sccp|tup) ssn SSN'>
+      <params>
+        <param name='routing-key' doc='Define a routing key' />
+        <param name='RCONTEXT' doc='Routing context number' />
+        <param name='DPC' doc='Destination Point Code' />
+        <param name='si' doc='Match on Service Indicator' />
+        <param name='aal2' doc='ATM Adaption Layer 2' />
+        <param name='bicc' doc='Bearer Independent Call Control' />
+        <param name='b-isup' doc='Broadband ISDN User Part' />
+        <param name='h248' doc='H.248' />
+        <param name='isup' doc='ISDN User Part' />
+        <param name='sat-isup' doc='Sattelite ISDN User Part' />
+        <param name='sccp' doc='Signalling Connection Control Part' />
+        <param name='tup' doc='Telephony User Part' />
+        <param name='ssn' doc='Match on Sub-System Number' />
+        <param name='SSN' doc='Sub-System Number to match on' />
+      </params>
+    </command>
+    <command id='point-code override dpc PC'>
+      <params>
+        <param name='point-code' doc='Point Code Specific Features' />
+        <param name='override' doc='Override (force) a point-code to hard-coded value' />
+        <param name='dpc' doc='Override Source Point Code' />
+        <param name='PC' doc='Override Destination Point Code' />
+      </params>
+    </command>
+  </node>
+  <node id='config-cs7-asp'>
+    <name>config-cs7-asp</name>
+    <command id='description .TEXT'>
+      <params>
+        <param name='description' doc='Save human-readable description of the object' />
+        <param name='.TEXT' doc='Text until the end of the line' />
+      </params>
+    </command>
+    <command id='remote-ip A.B.C.D'>
+      <params>
+        <param name='remote-ip' doc='Specify Remote IP Address of ASP' />
+        <param name='A.B.C.D' doc='Remote IP Address of ASP' />
+      </params>
+    </command>
+    <command id='local-ip A.B.C.D'>
+      <params>
+        <param name='local-ip' doc='Specify Local IP Address from which to contact ASP' />
+        <param name='A.B.C.D' doc='Local IP Address from which to contact of ASP' />
+      </params>
+    </command>
+    <command id='qos-class &lt;0-255&gt;'>
+      <params>
+        <param name='qos-class' doc='Specify QoS Class of ASP' />
+        <param name='&lt;0-255&gt;' doc='QoS Class of ASP' />
+      </params>
+    </command>
+    <command id='block'>
+      <params>
+        <param name='block' doc='Allows a SCTP Association with ASP, but doesn&apos;t let it become active' />
+      </params>
+    </command>
+    <command id='shutdown'>
+      <params>
+        <param name='shutdown' doc='Terminates SCTP association; New associations will be rejected' />
+      </params>
+    </command>
+  </node>
+  <node id='config-cs7-sccpaddr'>
+    <name>config-cs7-sccpaddr</name>
+    <command id='no point-code'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='point-code' doc='Remove point-code Number' />
+      </params>
+    </command>
+    <command id='no subsystem-number'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='subsystem-number' doc='Remove Subsystem Number' />
+      </params>
+    </command>
+    <command id='no global-title'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='global-title' doc='Remove Global Title' />
+      </params>
+    </command>
+    <command id='routing-indicator (GT|PC|IP)'>
+      <params>
+        <param name='routing-indicator' doc='Add Routing Indicator' />
+        <param name='GT' doc='by global-title' />
+        <param name='PC' doc='by point-code' />
+        <param name='IP' doc='by ip-address' />
+      </params>
+    </command>
+    <command id='point-code POINT_CODE'>
+      <params>
+        <param name='point-code' doc='Add point-code Number' />
+        <param name='POINT_CODE' doc='PC' />
+      </params>
+    </command>
+    <command id='subsystem-number &lt;0-4294967295&gt;'>
+      <params>
+        <param name='subsystem-number' doc='Add Subsystem Number' />
+        <param name='&lt;0-4294967295&gt;' doc='SSN' />
+      </params>
+    </command>
+    <command id='global-title'>
+      <params>
+        <param name='global-title' doc='Add/Modify Global Title' />
+      </params>
+    </command>
+  </node>
+  <node id='config-cs7-sccpaddr-gt'>
+    <name>config-cs7-sccpaddr-gt</name>
+    <command id='global-title-indicator &lt;0-15&gt;'>
+      <params>
+        <param name='global-title-indicator' doc='Set Global Title Indicator' />
+        <param name='&lt;0-15&gt;' doc='GTI' />
+      </params>
+    </command>
+    <command id='translation-type &lt;0-255&gt;'>
+      <params>
+        <param name='translation-type' doc='Set Global Title Translation Type' />
+        <param name='&lt;0-255&gt;' doc='TT' />
+      </params>
+    </command>
+    <command id='numbering-plan-indicator &lt;0-15&gt;'>
+      <params>
+        <param name='numbering-plan-indicator' doc='Set Global Title Numbering Plan Indicator' />
+        <param name='&lt;0-15&gt;' doc='NPI' />
+      </params>
+    </command>
+    <command id='nature-of-address-indicator &lt;0-127&gt;'>
+      <params>
+        <param name='nature-of-address-indicator' doc='Set Global Title Nature of Address Indicator' />
+        <param name='&lt;0-127&gt;' doc='NAI' />
+      </params>
+    </command>
+    <command id='digits DIGITS'>
+      <params>
+        <param name='digits' doc='Set Global Title Digits' />
+        <param name='DIGITS' doc='Number digits' />
+      </params>
+    </command>
+  </node>
+  <node id='config-sgsn'>
+    <name>config-sgsn</name>
+    <command id='gtp local-ip A.B.C.D'>
+      <params>
+        <param name='gtp' doc='GTP Parameters' />
+        <param name='local-ip' doc='Set the IP address for the local GTP bind for the Gp interface (towards the GGSNs). Note: in case you would like to run the GGSN on the same machine as the SGSN, you can not run both on the same IP address, since both sides are specified to use the same GTP port numbers (2123 and 2152). For example, you could use 127.0.0.1 for the SGSN and 127.0.0.2 for the GGSN in such situations.' />
+        <param name='A.B.C.D' doc='IPv4 Address' />
+      </params>
+    </command>
+    <command id='ggsn &lt;0-255&gt; remote-ip A.B.C.D'>
+      <params>
+        <param name='ggsn' doc='Configure the GGSN information' />
+        <param name='&lt;0-255&gt;' doc='GGSN Number' />
+        <param name='remote-ip' doc='Configure this static GGSN to use the specified remote IP address.' />
+        <param name='A.B.C.D' doc='IPv4 Address' />
+      </params>
+    </command>
+    <command id='ggsn &lt;0-255&gt; gtp-version (0|1)'>
+      <params>
+        <param name='ggsn' doc='Configure the GGSN information' />
+        <param name='&lt;0-255&gt;' doc='GGSN Number' />
+        <param name='gtp-version' doc='GTP Version' />
+        <param name='0' doc='Version 0' />
+        <param name='1' doc='Version 1' />
+      </params>
+    </command>
+    <command id='imsi-acl (add|del) IMSI'>
+      <params>
+        <param name='imsi-acl' doc='Access Control List of foreign IMSIs' />
+        <param name='add' doc='Add IMSI to ACL' />
+        <param name='del' doc='Remove IMSI from ACL' />
+        <param name='IMSI' doc='IMSI of subscriber' />
+      </params>
+    </command>
+    <command id='auth-policy (accept-all|closed|acl-only|remote)'>
+      <params>
+        <param name='auth-policy' doc='Configure the Authorization policy of the SGSN. This setting determines which subscribers are permitted to register to the network.' />
+        <param name='accept-all' doc='Accept all IMSIs (DANGEROUS)' />
+        <param name='closed' doc='Accept only home network subscribers or those in the ACL' />
+        <param name='acl-only' doc='Accept only subscribers in the ACL' />
+        <param name='remote' doc='Use remote subscription data only (HLR)' />
+      </params>
+    </command>
+    <command id='encryption (GEA0|GEA1|GEA2|GEA3|GEA4)'>
+      <params>
+        <param name='encryption' doc='Set encryption algorithm for SGSN' />
+        <param name='GEA0' doc='Use GEA0 (no encryption)' />
+        <param name='GEA1' doc='Use GEA1' />
+        <param name='GEA2' doc='Use GEA2' />
+        <param name='GEA3' doc='Use GEA3' />
+        <param name='GEA4' doc='Use GEA4' />
+      </params>
+    </command>
+    <command id='gsup remote-ip A.B.C.D'>
+      <params>
+        <param name='gsup' doc='GSUP Parameters' />
+        <param name='remote-ip' doc='Set the IP address of the remote GSUP server (e.g. OsmoHLR). This setting only applies if &apos;auth-policy remote&apos; is used.' />
+        <param name='A.B.C.D' doc='IPv4 Address' />
+      </params>
+    </command>
+    <command id='gsup remote-port &lt;0-65535&gt;'>
+      <params>
+        <param name='gsup' doc='GSUP Parameters' />
+        <param name='remote-port' doc='Set the TCP port of the remote GSUP server, see also &apos;gsup remote-ip&apos;' />
+        <param name='&lt;0-65535&gt;' doc='Remote TCP port' />
+      </params>
+    </command>
+    <command id='gsup oap-id &lt;0-65535&gt;'>
+      <params>
+        <param name='gsup' doc='GSUP Parameters' />
+        <param name='oap-id' doc='Set the OAP client ID for authentication on the GSUP protocol. This setting only applies if &apos;auth-policy remote&apos; is used.' />
+        <param name='&lt;0-65535&gt;' doc='OAP client ID (0 == disabled)' />
+      </params>
+    </command>
+    <command id='gsup oap-k K'>
+      <params>
+        <param name='gsup' doc='GSUP Parameters' />
+        <param name='oap-k' doc='Set the OAP shared secret key K for authentication on the GSUP protocol. This setting only applies if auth-policy remote is used.' />
+        <param name='K' doc='K value (16 byte) hex' />
+      </params>
+    </command>
+    <command id='gsup oap-opc OPC'>
+      <params>
+        <param name='gsup' doc='GSUP Parameters' />
+        <param name='oap-opc' doc='Set the OAP shared secret OPC for authentication on the GSUP protocol. This setting only applies if auth-policy remote is used.' />
+        <param name='OPC' doc='OPC value (16 byte) hex' />
+      </params>
+    </command>
+    <command id='apn APNAME ggsn &lt;0-255&gt;'>
+      <params>
+        <param name='apn' doc='Configure the information per APN' />
+        <param name='APNAME' doc='The APN gateway name optionally prefixed by &apos;*&apos; (wildcard)' />
+        <param name='ggsn' doc='Select the GGSN to use for the given APN gateway prefix' />
+        <param name='&lt;0-255&gt;' doc='The GGSN id' />
+      </params>
+    </command>
+    <command id='apn APNAME imsi-prefix IMSIPRE ggsn &lt;0-255&gt;'>
+      <params>
+        <param name='apn' doc='Configure the information per APN' />
+        <param name='APNAME' doc='The APN gateway name optionally prefixed by &apos;*&apos; (wildcard)' />
+        <param name='imsi-prefix' doc='Select the GGSN to use for the given APN gateway prefix if and only if the IMSI matches the given prefix.' />
+        <param name='IMSIPRE' doc='An IMSI prefix' />
+        <param name='ggsn' doc='Select the GGSN to use when APN gateway and IMSI prefix match' />
+        <param name='&lt;0-255&gt;' doc='The GGSN id' />
+      </params>
+    </command>
+    <command id='access-point-name NAME'>
+      <params>
+        <param name='access-point-name' doc='Globally allow the given APN name for all subscribers.' />
+        <param name='NAME' doc='Add this NAME to the list' />
+      </params>
+    </command>
+    <command id='no access-point-name NAME'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='access-point-name' doc='Configure a global list of allowed APNs' />
+        <param name='NAME' doc='Remove entry with NAME' />
+      </params>
+    </command>
+    <command id='cdr filename NAME'>
+      <params>
+        <param name='cdr' doc='CDR' />
+        <param name='filename' doc='Set the file name for the call-data-record file, logging the data usage of each subscriber.' />
+        <param name='NAME' doc='filename' />
+      </params>
+    </command>
+    <command id='no cdr filename'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='cdr' doc='CDR' />
+        <param name='filename' doc='Disable saving CDR to file' />
+      </params>
+    </command>
+    <command id='cdr trap'>
+      <params>
+        <param name='cdr' doc='CDR' />
+        <param name='trap' doc='Enable sending CDR via TRAP CTRL messages' />
+      </params>
+    </command>
+    <command id='no cdr trap'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='cdr' doc='CDR' />
+        <param name='trap' doc='Disable sending CDR via TRAP CTRL messages' />
+      </params>
+    </command>
+    <command id='cdr interval &lt;1-2147483647&gt;'>
+      <params>
+        <param name='cdr' doc='CDR' />
+        <param name='interval' doc='Set the interval for the call-data-record file' />
+        <param name='&lt;1-2147483647&gt;' doc='interval in seconds' />
+      </params>
+    </command>
+    <command id='ggsn dynamic'>
+      <params>
+        <param name='ggsn' doc='Configure the GGSN information' />
+        <param name='dynamic' doc='Enable dynamic resolving of GGSNs based on DNS resolving the APN name like in a GRX-style setup. Changing this setting requires a restart.' />
+      </params>
+    </command>
+    <command id='grx-dns-add A.B.C.D'>
+      <params>
+        <param name='grx-dns-add' doc='Use the specified IP address for DNS-resolving the AP names to GGSN IP addresses' />
+        <param name='A.B.C.D' doc='IPv4 address' />
+      </params>
+    </command>
+    <command id='timer t3312 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3312' doc='Periodic RA Update timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3322 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3322' doc='Detach request -&gt; accept timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3350 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3350' doc='Waiting for ATT/RAU/TMSI_COMPL timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3360 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3360' doc='Waiting for AUTH/CIPH response timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3370 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3370' doc='Waiting for IDENTITY response timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3313 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3313' doc='Waiting for paging response timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3314 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3314' doc='Force to STANDBY on expiry timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3316 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3316' doc='AA-Ready timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3385 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3385' doc='Wait for ACT PDP CTX REQ timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3386 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3386' doc='Wait for MODIFY PDP CTX ACK timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3395 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3395' doc='Wait for DEACT PDP CTX ACK timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='timer t3397 &lt;0-65535&gt;'>
+      <params>
+        <param name='timer' doc='Configure GPRS Timers' />
+        <param name='t3397' doc='Wait for DEACT AA PDP CTX ACK timer (s)' />
+        <param name='&lt;0-65535&gt;' doc='Timer Value in seconds' />
+      </params>
+    </command>
+    <command id='no compression rfc1144'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='compression' doc='Configure compression' />
+        <param name='rfc1144' doc='disable rfc1144 TCP/IP header compression' />
+      </params>
+    </command>
+    <command id='compression rfc1144 active slots &lt;1-256&gt;'>
+      <params>
+        <param name='compression' doc='Configure compression' />
+        <param name='rfc1144' doc='RFC1144 Header compresion scheme' />
+        <param name='active' doc='Compression is actively proposed' />
+        <param name='slots' doc='Number of compression state slots' />
+        <param name='&lt;1-256&gt;' doc='Number of compression state slots' />
+      </params>
+    </command>
+    <command id='compression rfc1144 passive'>
+      <params>
+        <param name='compression' doc='Configure compression' />
+        <param name='rfc1144' doc='RFC1144 Header compresion scheme' />
+        <param name='passive' doc='Compression is available on request' />
+      </params>
+    </command>
+    <command id='no compression v42bis'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='compression' doc='Configure compression' />
+        <param name='v42bis' doc='disable V.42bis data compression' />
+      </params>
+    </command>
+    <command id='compression v42bis active direction (ms|sgsn|both) codewords &lt;512-65535&gt; strlen &lt;6-250&gt;'>
+      <params>
+        <param name='compression' doc='Configure compression' />
+        <param name='v42bis' doc='V.42bis data compresion scheme' />
+        <param name='active' doc='Compression is actively proposed' />
+        <param name='direction' doc='Direction in which the compression shall be active (p0)' />
+        <param name='ms' doc='Compress ms-&gt;sgsn direction only' />
+        <param name='sgsn' doc='Compress sgsn-&gt;ms direction only' />
+        <param name='both' doc='Both directions' />
+        <param name='codewords' doc='Number of codewords (p1)' />
+        <param name='&lt;512-65535&gt;' doc='Number of codewords' />
+        <param name='strlen' doc='Maximum string length (p2)' />
+        <param name='&lt;6-250&gt;' doc='Maximum string length' />
+      </params>
+    </command>
+    <command id='compression v42bis passive'>
+      <params>
+        <param name='compression' doc='Configure compression' />
+        <param name='v42bis' doc='V.42bis data compresion scheme' />
+        <param name='passive' doc='Compression is available on request' />
+      </params>
+    </command>
+    <command id='iu rab-assign-addr-enc (x213|v4raw)'>
+      <params>
+        <param name='iu' doc='Iu interface protocol options' />
+        <param name='rab-assign-addr-enc' doc='Choose RAB Assignment&apos;s Transport Layer Address encoding' />
+        <param name='x213' doc='ITU-T X.213 compliant address encoding (default)' />
+        <param name='v4raw' doc='32bit length raw IPv4 address (for ip.access nano3G)' />
+      </params>
+    </command>
+    <command id='asn1 debug (1|0)'>
+      <params>
+        <param name='asn1' doc='ASN.1 settings' />
+        <param name='debug' doc='Enable ASN.1 debug messages' />
+        <param name='1' doc='Log ASN.1 debug messages to stderr' />
+        <param name='0' doc='Do not log ASN.1 debug messages to stderr' />
+      </params>
+    </command>
+    <command id='asn1 xer-print (1|0)'>
+      <params>
+        <param name='asn1' doc='ASN.1 settings' />
+        <param name='xer-print' doc='Log human readable representations of all ASN.1 messages to stderr' />
+        <param name='1' doc='Log XML representation of all ASN.1 messages to stderr' />
+        <param name='0' doc='Do not log decoded ASN.1 messages to stderr' />
+      </params>
+    </command>
+  </node>
+</vtydoc>
