diff --git a/doc/manuals/Makefile.am b/doc/manuals/Makefile.am
index cd57cf1..fa342ab 100644
--- a/doc/manuals/Makefile.am
+++ b/doc/manuals/Makefile.am
@@ -1,23 +1,26 @@
-EXTRA_DIST = osmosgsn-usermanual.adoc \
-    osmosgsn-usermanual-docinfo.xml \
-    osmosgsn-vty-reference.xml \
+EXTRA_DIST = \
     osmogbproxy-usermanual.adoc \
     osmogbproxy-usermanual-docinfo.xml \
-    regen_doc.sh \
-    chapters \
-    vty \
     osmogbproxy-vty-reference.xml \
-    vty-osmogbproxy \
+    chapters \
+    regen_doc.sh \
+    vty \
     $(NULL)
 
 if BUILD_MANUALS
-  ASCIIDOC = osmosgsn-usermanual.adoc osmogbproxy-usermanual.adoc
-  ASCIIDOC_DEPS = $(srcdir)/chapters/*.adoc
+  ASCIIDOC = osmogbproxy-usermanual.adoc
   include $(OSMO_GSM_MANUALS_DIR)/build/Makefile.asciidoc.inc
+  osmogbproxy-usermanual.pdf: $(srcdir)/chapters/*.adoc #$(srcdir)/chapters/*.dot
 
-  VTY_REFERENCE = osmosgsn-vty-reference.xml osmogbproxy-vty-reference.xml
+  VTY_REFERENCE = osmogbproxy-vty-reference.xml
+
+  BUILT_REFERENCE_XML = $(builddir)/vty/gbproxy_vty_reference.xml
+  $(builddir)/vty/gbproxy_vty_reference.xml: $(top_builddir)/src/osmo-gbproxy
+	mkdir -p $(builddir)/vty
+	$(top_builddir)/src/osmo-gbproxy --vty-ref-xml > $@
+
   include $(OSMO_GSM_MANUALS_DIR)/build/Makefile.vty-reference.inc
 
-  OSMO_REPOSITORY = osmo-sgsn
+  OSMO_REPOSITORY = osmo-gbproxy
   include $(OSMO_GSM_MANUALS_DIR)/build/Makefile.common.inc
 endif
diff --git a/doc/manuals/chapters/configuration.adoc b/doc/manuals/chapters/configuration.adoc
deleted file mode 100644
index 7d3072e..0000000
--- a/doc/manuals/chapters/configuration.adoc
+++ /dev/null
@@ -1,378 +0,0 @@
-== Configuring OsmoSGSN
-
-Contrary to other network elements (like OsmoBSC, OsmoNITB), the
-OsmoSGSN has a relatively simple configuration.
-
-On the one hand, this is primary because the PCU configuration happens
-from the BSC side.
-
-On the other hand, it is because the Gb interface does not need an
-explicit configuration of each PCU connecting to the SGSN. The
-administrator only has to ensure that the NS and BSSGP layer identities
-(NSEI, NSVCI, BVCI) are unique for each PCU connecting to the SGSN.
-
-=== Configuring the Gp interface
-
-The Gp interface is the GTP-C and GTP-U based interface between the SGSN
-and the GGSNs.  It is implemented via UDP on well-known source and
-destination ports.
-
-When an MS requests establishment of a PDP context, it specifies the APN
-(Access Point Name) to which the context shall be established.  This APN
-determines which GGSN shall be used, and that in turn determines which
-external IP network the MS will be connected to.
-
-There are two modes in which GGSNs can be configured:
-
-. static GGSN/APN configuration
-. dynamic GGSN/APN configuration
-
-==== Static GGSN/APN configuration
-
-In this mode, there is a static list of GGSNs and APNs configured in
-OsmoSGSN via the VTY / config file.
-
-This is a non-standard method outside of the 3GPP specifications for the
-SGSN, and is typically only used in private/small GPRS networks without
-any access to a GRX.
-
-.Example: Static GGSN/APN configuration (single catch-all GGSN)
-----
-OsmoSGSN(config-sgsn)# gtp local-ip 172.0.0.1 <1>
-OsmoSGSN(config-sgsn)# ggsn 0 remote-ip 127.0.0.2 <2>
-OsmoSGSN(config-sgsn)# ggsn 0 gtp-version 1 <3>
-OsmoSGSN(config-sgsn)# apn * ggsn 0 <4>
-----
-<1> Configure the local IP address at the SGSN used for Gp/GTP
-<2> Specify the remote IP address of the GGSN (for GGSN 0)
-<3> Specify the GTP protocol version used for GGSN 0
-<4> Route all APN names to GGSN 0
-
-
-==== Dynamic GGSN/APN configuration
-
-In this mode, the SGSN will use a DNS-based method to perform the lookup
-from the APN (as specified by the MS) towards the GGSN IP address.
-
-This is the official method as per the 3GPP specifications for the SGSN,
-and what is used on GRX.
-
-.Example: Dynamic GGSN/APN configuration
-----
-OsmoSGSN(config-sgsn)# gtp local-ip 192.168.0.11 <1>
-OsmoSGSN(config-sgsn)# ggsn dynamic <2>
-OsmoSGSN(config-sgsn)# grx-dns-add 1.2.3.4 <3>
-----
-<1> Configure the local IP address at the SGSN used for Gp/GTP
-<2> Enable the dynamic GGSN resolving mode
-<3> Specify the IP address of a DNS server for APN resolution
-
-[[auth-pol]]
-=== Authorization Policy
-
-The authorization policy controls by which rules a subscriber is accepted or
-rejected. The possible options range from accepting just all subscribers without
-further checking, to a fine grained access-control, handled by an external HLR.
-
-accept-all:: All subscribers that attempt to attach to the GPRS network are
-accepted without further checking. This option is intended to be used for
-testing in a controlled environment only. A wide-open network may attract
-subscribers from foreign networks and disrupt their service. It is highly
-recommended to pick one of the options below.
-
-remote:: This option allows to connect OsmoSGSN to an external HLR via the
-GSUP protocol. This will be the preferred option in larger networks.
-
-acl-only:: If no external HLR is available, the network operator has the
-option to control the access using an access control list. The access control
-list contains the IMSI numbers of the allowed subscribers. This method offers
-fine grained access control and is ideal for small networks and lab test
-environments.
-
-closed:: This policy mode softens the strict *acl-only* only mode by also
-implicitly accepting home network subscribers. The decision is made by the MCC
-and MNC part of the IMSI number. The combination of MCC and MNC fully identifies
-a subscribers home network, also known as a Home Network Identity (HNI, i.e.
-MCC and MNC found at the start of the IMSI, e.g. MCC 901 and MNC 700 with
-IMSI 901700000003080).
-
-NOTE: The policy mode *closed* must not be confused with the equally named
-policy that is defined for osmo-nitb!
-
-
-.Example: Assign or change authorization policy
-----
-OsmoSGSN> enable
-OsmoSGSN# configure terminal
-OsmoSGSN(config)# sgsn
-OsmoSGSN(config-sgsn)# auth-policy acl-only <1>
-OsmoSGSN(config-sgsn)# write <2>
-Configuration saved to sgsn.cfg
-OsmoSGSN(config-sgsn)# end
-OsmoSGSN# disable
-OsmoSGSN>
-----
-<1> 'acl-only' is selected as authorization policy
-<2> Saves current changes to cofiguration to make this policy
-persistent
-
-.Example: Access control list
-----
-sgsn
- auth-policy acl-only <1>
- imsi-acl add 001010000000003
- imsi-acl add 001010000000002
- imsi-acl add 001010000000001
- imsi-acl add 901700000000068 <2>
-----
-<1> Set the authorization policy
-<2> Add as many subscribers as required
-
-=== Subscriber Configuration
-
-As opposed to OsmoNITB, OsmoSGSN does not feature a built-in HLR.
-
-It can thus operate only in the following two modes:
-
-. Accessing an external HLR (or HLR gateway) via the GSUP protocol
-. Accepting subscribers based on internal ACL (access control list),
-  see also <<auth-pol>>
-
-==== Accessing an external HLR via GSUP
-
-The non-standard GSUP protocol was created to provide OsmoSGSN with
-access to an external HLR while avoiding the complexities of the
-TCAP/MAP protocol stack commonly used by HLRs.
-
-A custom HLR could either directly implement GSUP, or an external gateway
-can be used to convert GSUP to the respective MAP operations.
-
-The primitives/operations of GSUP are modelled to have a 1:1
-correspondence to their MAP counterparts.  However, the encoding is much
-simplified by use of a binary TLV encoding similar to Layer 3 of
-GSM/GPRS.
-
-GSUP performs a challenge-response authentication protocol called OAP,
-which uses the standard MILENAGE algorithm for mutual authentication
-between OsmoSGSN and the HLR/HLR-GW.
-
-[[sgsn-ex-gsup]]
-.Example: Using an external HLR via GSUP
-----
-OsmoSGSN(config-sgsn)# gsup remote-ip 2.3.4.5 <1>
-OsmoSGSN(config-sgsn)# gsup remote-port 10000 <2>
-OsmoSGSN(config-sgsn)# gsup oap-k 000102030405060708090a0b0c0d0e0f <3>
-OsmoSGSN(config-sgsn)# gsup oap-opc 101112131415161718191a1b1c1d1e1f <4>
-----
-<1> Configure the IP address of the (remote) HLR or HLR-GW
-<2> Configure the TCP port of the (remote) HLR or HLR-GW
-<3> Specify the OAP shared key
-<4> Specify the OAP shared OPC
-
-
-=== CDR configuration
-
-OsmoSGSN can write a text log file containing CDR (call data records),
-which are commonly used for accounting/billing purpose.
-
-.Example: CDR log file configuration
-----
-OsmoSGSN(config-sgsn)# cdr filename /var/log/osmosgsn.cdr
-OsmoSGSN(config-sgsn)# cdr interval 600 <1>
-----
-<1> Periodically log existing PDP contexts every 600 seconds (10 min)
-
-The CDR file is a simple CSV file including a header line naming the
-individual fields of each CSV line.
-
-==== CDR CTRL interface
-
-Independently of whether logging CDR to a file is enabled or not, OsmoSGSN can
-also provide delivery of CDR through the CTRL interface. CDR are sent by means
-of TRAP messages with variable name _cdr-v1_, and its value is filled using the
-same CSV line format as in the log file, but without CSV header line.
-
-.Example: CDR delivery through CTRL TRAP messages
-----
-OsmoSGSN(config-sgsn)# cdr trap
-----
-
-==== CDR Format
-
-[[sgsn-cdr]]
-.Description of CSV fields in OsmoSGSN CDR file
-[options="header",cols="15%,85%"]
-|===
-|Field Name|Description
-|timestamp|Timestamp in YYYYMMDDhhmmssXXX where XXX are milli-seconds
-|imsi|IMSI causing this CDR
-|imei|IMEI causing this CDR
-|msisdn|MSISDN causing this CDR (if known)
-|cell_id|Cell ID in which the MS was registered last
-|lac|Location Area Code in which the MS was registered last
-|hlr|HLR of the subscriber
-|event|Possible events are explained below in <<sgsn-cdr-event>>
-|===
-
-If the _event_ field describes a pdp context related action (starts with
-_pdp-_), then the following extra CSV fields are appended to the line:
-
-[[sgsn-cdr-pdp]]
-.Description of extra CSV fields for pdp context related events
-[options="header",cols="15%,85%"]
-|===
-|Field Name|Description
-|pdp_duration|duration of the PDP context so far
-|ggsn_addr|GGSN related to the PDP context
-|sgsn_addr|SGSN related to the PDP context
-|apni|APN identifier of the PDP context
-|eua_addr|IP address allocated to the PDP context
-|vol_in|Number of bytes in MO direction
-|vol_out|Number of bytes in MT direction
-|charging_id|Related charging ID
-|===
-
-[[sgsn-cdr-event]]
-.Description of OsmoSGSN CDR Events
-[options="header",cols="15%,85%"]
-|===
-|Event|Description
-|attach|GMM ATTACH COMPLETE about to be sent to MS
-|update|GMM ROUTING AREA UPDATE COMPLETE about to be sent to MS
-|detach|GMM DETACH REQUEST received from MS
-|free|Release of the MM context memory
-|pdp-act|GTP CREATE PDP CONTEXT CONFIRM received from GGSN
-|pdp-deact|GTP DELETE PDP CONTEXT CONFIRM received from GGSN
-|pdp-terminate|Forced PDP context termination during MM context release
-|pdp-free|Release of the PDP context memory
-|pdp-periodic|Triggered by periodic timer, see VTY cmd _cdr interval_
-|===
-
-
-=== User traffic compression
-
-In order to save GPRS bandwith, OsmoSGSN implements header and data
-compression schemes which will reduce the packet length.
-
-==== Header compression
-
-On TCP/IP connections, each packet is prepended with a fairly long TCP/IP
-header. The header contains a lot of static information that never changes
-throughout the connection. (source and destination address, port numbers etc.)
-OsmoSGSN implements a TCP/IP header compression scheme called RFC1144, also
-known as SLHC. This type of header compression removes the TCP/IP header
-entirely and replaces it with a shorter version, that only contains the
-information that is absolutely necessary to identify and check the packet.
-The receiving part then restores the original header and forwards it to higher
-layers.
-
-*compression rfc1144 passive*::
-TCP/IP header compression has to be actively requested by the modem. The
-network will not promote compression by itself. This is the recommended mode
-of operation.
-
-*compression rfc1144 active slots <1-256>*::
-TCP/IP header compression is actively promoted by the network. Modems may still
-actively request different compression parameters or reject the offered
-compression parameters entirely. The number of slots is the maximum number
-of packet headers per subscriber that can be stored in the codebook.
-
-.Example: Accept compression if requested
-----
-sgsn
- compression rfc1144 passive
-----
-
-.Example: Actively promote compression
-----
-sgsn
- compression rfc1144 active slots 8
-----
-
-.Example: Turn off compression
-----
-sgsn
- no compression rfc1144
-----
-
-NOTE: The usage of TCP/IP options may disturb the RFC1144 header compression
-scheme. TCP/IP options may render RFC1144 ineffective if variable data is
-encoded into the option section of the TCP/IP packet. (e.g. TCP option 8,
-Timestamp)
-
-
-==== Data compression
-
-Data compression works on the raw packet data, including the header part of the
-packet. If enabled, header compression is applied first before data compression
-is applied. OsmoSGSN implements the V.42bis data compression scheme.
-
-*compression v42bis passive*::
-V42bis data compression has to be actively requested by the modem. The network
-will not promote compression by itself. This is the recommended mode of
-operation.
-
-*compression v42bis active direction (ms|sgsn|both) codewords <512-65535> strlen <6-250>*::
-V42bis data compression is actively promoted by the network. Modems may still
-actively request different compression parameters or reject the offered
-compression parameters entirely. The direction configures which sides are
-allowed to send compressed packets. For most cases, compressing 'both'
-directions will be the preferred option. The following to parameters configure
-the codebook size by the maxium number ('codewords') and size ('strlen') of
-entries.
-
-.Example: Accept compression if requested
-----
-sgsn
- compression v42bis passive
-----
-
-.Example: Actively promote compression
-----
-sgsn
- compression v42bis active direction both codewords 512 strlen 20
-----
-
-.Example: Turn off compression
-----
-sgsn
- no compression v42bis
-----
-
-=== Encryption
-
-Encryption can be enabled if the auth-policy is set to remote and the
-HLR subscriber entries contain the keys of the SIM card. See
-<<sgsn-ex-gsup>> on how to connect to an external HLR.
-
-.Example: Turn on encryption (GEA3)
-----
-sgsn
- encryption GEA3
-----
-
-.Example: Turn off encryption (GEA0)
-----
-sgsn
- encryption GEA0
-----
-
-=== Configure SCCP/M3UA to accept _IuPS_ links
-
-OsmoSGSN acts as client to contact an STP instance and establish an SCCP/M3UA
-link.
-
-An example configuration of OsmoSGSN's SCCP link:
-
-----
-cs7 instance 0
- point-code 0.23.4
- asp asp-clnt-OsmoSGSN 2905 0 m3ua
-  remote-ip 127.0.0.1
-  sctp-role client
- as as-clnt-OsmoSGSN m3ua
-  asp asp-clnt-OsmoSGSN
-  routing-key 0 0.23.4
-----
-
-This configuration is explained in detail in <<cs7_config>>.
diff --git a/doc/manuals/chapters/control.adoc b/doc/manuals/chapters/control.adoc
deleted file mode 100644
index 0f2bfae..0000000
--- a/doc/manuals/chapters/control.adoc
+++ /dev/null
@@ -1,23 +0,0 @@
-[[control]]
-== Control interface
-
-The actual protocol is described in <<common-control-if>>, the variables
-common to all programs using it are described in <<ctrl_common_vars>>. Here we
-describe variables specific to OsmoSGSN.
-
-.Variables available over control interface
-[options="header",width="100%",cols="20%,5%,5%,50%,20%"]
-|===
-|Name|Access|Trap|Value|Comment
-|subscriber-list-active-v1|RO|No|"<imsi>,<addr>"|See <<subs>> for details.
-|===
-
-[[subs]]
-=== subscriber-list-active-v1
-
-Return the list of active subscribers as a concatenated set of pairs "<imsi>",
-"addr" where first element of the pair is subscriber's IMSI and the second
-element (which might be empty) is the subscriber's address. The address value
-might be "none", "invalid" and "PPP" in addition to actual IP address. In case
-of IP address it will be prefixed with "IPv4" or "IPv6" string depending on the
-version of IP protocol.
diff --git a/doc/manuals/chapters/counters.adoc b/doc/manuals/chapters/counters.adoc
deleted file mode 100644
index 7fbb10c..0000000
--- a/doc/manuals/chapters/counters.adoc
+++ /dev/null
@@ -1,4 +0,0 @@
-[[counters]]
-== Counters
-
-include::./counters_generated.adoc[]
diff --git a/doc/manuals/chapters/counters_generated.adoc b/doc/manuals/chapters/counters_generated.adoc
index dac46aa..e16560c 100644
--- a/doc/manuals/chapters/counters_generated.adoc
+++ b/doc/manuals/chapters/counters_generated.adoc
@@ -1,52 +1,10 @@
 
 // autogenerated by show asciidoc counters
-These counters and their description based on OsmoSGSN 1.4.0.31-05fe (OsmoSGSN).
+These counters and their description are based on OsmoGbProxy UNKNOWN-dirty (OsmoGbProxy).
 
 === Rate Counters
 
 // generating tables for rate_ctr_group
-// rate_ctr_group table BSSGP Peer Statistics
-.bssgp:bss_ctx - BSSGP Peer Statistics 
-[options="header"]
-|===
-| Name | Reference | Description
-| packets:in | <<bssgp:bss_ctx_packets:in>> | Packets at BSSGP Level ( In)
-| packets:out | <<bssgp:bss_ctx_packets:out>> | Packets at BSSGP Level (Out)
-| bytes:in | <<bssgp:bss_ctx_bytes:in>> | Bytes at BSSGP Level   ( In)
-| bytes:out | <<bssgp:bss_ctx_bytes:out>> | Bytes at BSSGP Level   (Out)
-| blocked | <<bssgp:bss_ctx_blocked>> | BVC Blocking count
-| discarded | <<bssgp:bss_ctx_discarded>> | BVC LLC Discarded count
-| status | <<bssgp:bss_ctx_status>> | BVC Status count
-|===
-// rate_ctr_group table SGSN Overall Statistics
-.sgsn - SGSN Overall Statistics
-[options="header"]
-|===
-| Name | Reference | Description
-| llc:dl_bytes | <<sgsn_llc:dl_bytes>> | Count sent LLC bytes before giving it to the bssgp layer
-| llc:ul_bytes | <<sgsn_llc:ul_bytes>> | Count successful received LLC bytes (encrypt & fcs correct)
-| llc:dl_packets | <<sgsn_llc:dl_packets>> | Count successful sent LLC packets before giving it to the bssgp layer
-| llc:ul_packets | <<sgsn_llc:ul_packets>> | Count successful received LLC packets (encrypt & fcs correct)
-| gprs:attach_requested | <<sgsn_gprs:attach_requested>> | Received attach requests
-| gprs:attach_accepted | <<sgsn_gprs:attach_accepted>> | Sent attach accepts
-| gprs:attach_rejected | <<sgsn_gprs:attach_rejected>> | Sent attach rejects
-| gprs:detach_requested | <<sgsn_gprs:detach_requested>> | Received detach requests
-| gprs:detach_acked | <<sgsn_gprs:detach_acked>> | Sent detach acks
-| gprs:routing_area_requested | <<sgsn_gprs:routing_area_requested>> | Received routing area requests
-| gprs:routing_area_requested | <<sgsn_gprs:routing_area_requested>> | Sent routing area acks
-| gprs:routing_area_requested | <<sgsn_gprs:routing_area_requested>> | Sent routing area rejects
-| pdp:activate_requested | <<sgsn_pdp:activate_requested>> | Received activate requests
-| pdp:activate_rejected | <<sgsn_pdp:activate_rejected>> | Sent activate rejects
-| pdp:activate_accepted | <<sgsn_pdp:activate_accepted>> | Sent activate accepts
-| pdp:request_activated | <<sgsn_pdp:request_activated>> | unused
-| pdp:request_activate_rejected | <<sgsn_pdp:request_activate_rejected>> | unused
-| pdp:modify_requested | <<sgsn_pdp:modify_requested>> | unused
-| pdp:modify_accepted | <<sgsn_pdp:modify_accepted>> | unused
-| pdp:dl_deactivate_requested | <<sgsn_pdp:dl_deactivate_requested>> | Sent deactivate requests
-| pdp:dl_deactivate_accepted | <<sgsn_pdp:dl_deactivate_accepted>> | Sent deactivate accepted
-| pdp:ul_deactivate_requested | <<sgsn_pdp:ul_deactivate_requested>> | Received deactivate requests
-| pdp:ul_deactivate_accepted | <<sgsn_pdp:ul_deactivate_accepted>> | Received deactivate accepts
-|===
 // rate_ctr_group table NSVC Peer Statistics
 .ns:nsvc - NSVC Peer Statistics
 [options="header"]
@@ -54,16 +12,46 @@
 | Name | Reference | Description
 | packets:in | <<ns:nsvc_packets:in>> | Packets at NS Level  ( In)
 | packets:out | <<ns:nsvc_packets:out>> | Packets at NS Level  (Out)
+| packets:out:drop | <<ns:nsvc_packets:out:drop>> | Dropped Packets      (Out)
 | bytes:in | <<ns:nsvc_bytes:in>> | Bytes at NS Level    ( In)
 | bytes:out | <<ns:nsvc_bytes:out>> | Bytes at NS Level    (Out)
-| blocked | <<ns:nsvc_blocked>> | NS-VC Block count
-| dead | <<ns:nsvc_dead>> | NS-VC gone dead count
+| bytes:out:drop | <<ns:nsvc_bytes:out:drop>> | Dropped Bytes        (Out)
+| blocked | <<ns:nsvc_blocked>> | NS-VC Block count         
+| unblocked | <<ns:nsvc_unblocked>> | NS-VC Unblock count       
+| dead | <<ns:nsvc_dead>> | NS-VC gone dead count     
 | replaced | <<ns:nsvc_replaced>> | NS-VC replaced other count
-| nsei-chg | <<ns:nsvc_nsei-chg>> | NS-VC changed NSEI count
-| inv-nsvci | <<ns:nsvc_inv-nsvci>> | NS-VCI was invalid count
-| inv-nsei | <<ns:nsvc_inv-nsei>> | NSEI was invalid count
-| lost:alive | <<ns:nsvc_lost:alive>> | ALIVE ACK missing count
-| lost:reset | <<ns:nsvc_lost:reset>> | RESET ACK missing count
+| nsei-chg | <<ns:nsvc_nsei-chg>> | NS-VC changed NSEI count  
+| lost:alive | <<ns:nsvc_lost:alive>> | ALIVE ACK missing count   
+| lost:reset | <<ns:nsvc_lost:reset>> | RESET ACK missing count   
+|===
+// rate_ctr_group table GBProxy Peer Statistics
+.gbproxy:peer - GBProxy Peer Statistics
+[options="header"]
+|===
+| Name | Reference | Description
+| blocked | <<gbproxy:peer_blocked>> | BVC Block                       
+| unblocked | <<gbproxy:peer_unblocked>> | BVC Unblock                     
+| dropped | <<gbproxy:peer_dropped>> | BVC blocked, dropped packet     
+| inv-nsei | <<gbproxy:peer_inv-nsei>> | NSEI mismatch                   
+| tx-err | <<gbproxy:peer_tx-err>> | NS Transmission error           
+|===
+// rate_ctr_group table GBProxy Global Statistics
+.gbproxy:global - GBProxy Global Statistics
+[options="header"]
+|===
+| Name | Reference | Description
+| inv-bvci | <<gbproxy:global_inv-bvci>> | Invalid BVC Identifier          
+| inv-lai | <<gbproxy:global_inv-lai>> | Invalid Location Area Identifier
+| inv-rai | <<gbproxy:global_inv-rai>> | Invalid Routing Area Identifier 
+| inv-nsei | <<gbproxy:global_inv-nsei>> | No BVC established for NSEI     
+| proto-err:bss | <<gbproxy:global_proto-err:bss>> | BSSGP protocol error      (BSS )
+| proto-err:sgsn | <<gbproxy:global_proto-err:sgsn>> | BSSGP protocol error      (SGSN)
+| not-supp:bss | <<gbproxy:global_not-supp:bss>> | Feature not supported     (BSS )
+| not-supp:sgsn | <<gbproxy:global_not-supp:sgsn>> | Feature not supported     (SGSN)
+| restart:sgsn | <<gbproxy:global_restart:sgsn>> | Restarted RESET procedure (SGSN)
+| tx-err:sgsn | <<gbproxy:global_tx-err:sgsn>> | NS Transmission error     (SGSN)
+| error | <<gbproxy:global_error>> | Other error                     
+| mod-peer-err | <<gbproxy:global_mod-peer-err>> | Patch error: no peer            
 |===
 == Osmo Stat Items
 
@@ -76,6 +64,14 @@
 | Name | Reference | Description | Unit
 | alive.delay | <<ns.nsvc_alive.delay>> | ALIVE response time         | ms
 |===
+NS Bind Statistics
+// osmo_stat_item_group table NS Bind Statistics
+.ns.bind - NS Bind Statistics
+[options="header"]
+|===
+| Name | Reference | Description | Unit
+| tx_backlog_length | <<ns.bind_tx_backlog_length>> | Transmit backlog length | packets
+|===
 == Osmo Counters
 
 // generating tables for osmo_counters
diff --git a/doc/manuals/chapters/overview.adoc b/doc/manuals/chapters/overview.adoc
deleted file mode 100644
index e2c0107..0000000
--- a/doc/manuals/chapters/overview.adoc
+++ /dev/null
@@ -1,109 +0,0 @@
-[[chapter_introduction]]
-== Overview
-
-[[intro_overview]]
-=== About OsmoSGSN
-
-OsmoSGSN is the Osmocom implementation of the GPRS SGSN (Serving Gprs
-Support Node) element inside the GPRS network.  The SGSN plays a similar
-central function to the GPRS network as the MSC plays in the GSM
-network.
-
-The SGSN is connected on the downlink side to Gb interfaces of the BSS,
-specifically the PCU inside the BSS.  The SGSN is further connected by
-the GTP protocol to the GGSN which terminates the tunnels towards the
-external packet data network (e.g. IPv4).
-
-OsmoSGSN supports both a PCU that is co-located with(in) the BTS, as
-well as a PCU that is co-located with(in) the BSC.  In combination with
-OsmoNITB/OsmoBSC/OsmoBTS, the PCU is co-located within the BTS.
-
-[[fig-gprs-pcubts]]
-.GPRS network architecture with PCU in BTS
-[graphviz]
-----
-digraph G {
-        rankdir=LR;
-        MS0 [label="MS"];
-        MS1 [label="MS"];
-        MS0->BTS [label="Um"];
-        MS1->BTS [label="Um"];
-        BTS->BSC [label="Abis"];
-        BSC->MSC [label="A"];
-        BTS->PCU [label="pcu_sock"];
-        PCU->SGSN [label="Gb"];
-        SGSN->GGSN [label="GTP"];
-}
-----
-
-=== Software Components
-
-OsmoSGSN contains a variety of different software components, which
-we'll quickly describe in this section.
-
-==== Gb Implementation
-
-OsmoSGSN implements the ETSI/3GPP specified Gb interface, including TS
-08.16 (NS), TS 08.18 (BSSGP) and TS 08.64 (LLC) protocols. As transport
-layers for NS, it supports NS/IP (NS encapsulated in UDP/IP), as well as
-NS/FR/GRE/IP.  The latter is provided in order to use a Router with
-Ethernet and Frame Relay interface to convert to actual physical Frame
-Relay medium, which is not directly supported by OsmoSGSN.
-
-The actual Gb Implementation is part of the libosmogb library, which is
-in turn part of the libosmocore software package.  This allows the same
-Gb implementation to be used from osmo-pcu, osmo-gbproxy as well as
-OsmoSGSN.
-
-
-==== GTP Implementation
-
-OsmoSGSN uses the libgtp implementation originating from OsmoGGSN. It
-supports both GTPv0 and GTPv1.
-
-
-==== GMM Implementation
-
-The GPRS Mobility Management implementation is quite simplistic at this
-point. It supports the GPRS ATTACH and GPRS ROUTING AREA UPDATE
-procedures, as well as GPRS ATTACH and GPRS DETACH.
-
-==== LLC Implementation
-
-The LLC (Logical Link Control) implementation of OsmoSGSN only supports
-non-acknowledged mode, as this is the most common use case in real-world
-GPRS networks.
-
-It does support both TCP/IP header compression according to RFC1144 and
-payload compression according to V.42bis
-
-The LLC implementation does support LLC encryption with ciphers GEA3 and GEA4.
-For encryption to work the auth policy needs to be set to remote and the SGSN
-connected to an HLR containing the subscriber data including key material.
-Other auth policys will not work with encryption.
-
-==== Session Management Implementation
-
-The session management procedures ACTIVATE PDP CONTEXT and DEACTIVATE
-PDP CONTEXT are supported.  However, no MODIFY PDP CONTEXT and no
-Network-initiated PDP context activation is possible.  This is again
-covering the predominant use cases and configurations in GPRS real-world
-networks while skipping the more esoteric features.
-
-Multiple PDP contexts can be attached by a single MS.
-
-Multiple GGSNs can be configured and routing to a GGSN can be configured based
-on APN. Dynamic lookup of GGSNs though DNS-based APN resolving is also possible.
-
-=== Limitations
-
-At the time of writing, OsmoSGSN still has a number of limitations,
-which are a result of the demand-driven Open Source development model.
-If you require any of those features, please consider implementing and
-contributing them, or contracting the existing OsmoSGSN developers for
-performing that work.
-
-Known Limitations include:
-
-* No paging coordination between SGSN and MSC
-* No SMS over Ps support
diff --git a/doc/manuals/chapters/running.adoc b/doc/manuals/chapters/running.adoc
deleted file mode 100644
index 63c2b27..0000000
--- a/doc/manuals/chapters/running.adoc
+++ /dev/null
@@ -1,35 +0,0 @@
-== Running OsmoSGSN
-
-The OsmoSGSN executable (`osmo-sgsn`) offers the following command-line
-options:
-
-
-=== SYNOPSIS
-
-*osmo-sgsn* [-h|-V] [-d 'DBGMASK'] [-D] [-c 'CONFIGFILE'] [-s] [-e 'LOGLEVEL'] 
-
-
-=== OPTIONS
-
-*-h, --help*::
-	Print a short help message about the supported options
-*-V, --version*::
-	Print the compile-time version number of the OsmoSGSN program
-*-d, --debug 'DBGMASK','DBGLEVELS'*::
-	Set the log subsystems and levels for logging to stderr. This
-	has mostly been superseded by VTY-based logging configuration,
-	see <<logging>> for further information.
-*-D, --daemonize*::
-	Fork the process as a daemon into background.
-*-c, --config-file 'CONFIGFILE'*::
-	Specify the file and path name of the configuration file to be
-	used. If none is specified, use `osmo_sgsn.cfg` in the current
-	working directory.
-*-s, --disable-color*::
-	Disable colors for logging to stderr. This has mostly been
-	deprecated by VTY based logging configuration, see <<logging>>
-	for more information.
-*-e, --log-level 'LOGLEVEL'*::
-	Set the global log level for logging to stderr. This has mostly
-	been deprecated by VTY based logging configuration, see
-	<<logging>> for more information.
diff --git a/doc/manuals/osmogbproxy-usermanual.adoc b/doc/manuals/osmogbproxy-usermanual.adoc
index d19bdd4..f4da954 100644
--- a/doc/manuals/osmogbproxy-usermanual.adoc
+++ b/doc/manuals/osmogbproxy-usermanual.adoc
@@ -25,7 +25,7 @@
 
 include::./common/chapters/control_if.adoc[]
 
-//include::{srcdir}/chapters/counters.adoc[]
+include::{srcdir}/chapters/counters_generated.adoc[]
 
 include::./common/chapters/port_numbers.adoc[]
 
diff --git a/doc/manuals/osmogbproxy-vty-reference.xml b/doc/manuals/osmogbproxy-vty-reference.xml
index ecf2268..5c2a16a 100644
--- a/doc/manuals/osmogbproxy-vty-reference.xml
+++ b/doc/manuals/osmogbproxy-vty-reference.xml
@@ -6,7 +6,7 @@
 <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML 5.0//EN"
 "http://docbook.org/xml/5.0/dtd/docbook.dtd" [
 <!ENTITY chapter-vty      SYSTEM      "./common/chapters/vty.xml" >
-<!ENTITY sections-vty     SYSTEM      "generated/docbook_osmogbproxy-vty-reference.xml"  >
+<!ENTITY sections-vty     SYSTEM      "generated/docbook_vty.xml"  >
 ]>
 
 <book>
diff --git a/doc/manuals/osmosgsn-usermanual-docinfo.xml b/doc/manuals/osmosgsn-usermanual-docinfo.xml
deleted file mode 100644
index afbf109..0000000
--- a/doc/manuals/osmosgsn-usermanual-docinfo.xml
+++ /dev/null
@@ -1,54 +0,0 @@
-<revhistory>
-  <revision>
-    <revnumber>1</revnumber>
-    <date>January 13, 2013</date>
-    <authorinitials>HW</authorinitials>
-    <revremark>
-      Initial version.
-    </revremark>
-  </revision>
-  <revision>
-    <revnumber>2</revnumber>
-    <date>February 2016</date>
-    <authorinitials>HW</authorinitials>
-    <revremark>
-      Conversion to asciidoc, removal of sysmoBTS specific parts.
-    </revremark>
-  </revision>
-</revhistory>
-
-<authorgroup>
-  <author>
-    <firstname>Harald</firstname>
-    <surname>Welte</surname>
-    <email>hwelte@sysmocom.de</email>
-    <authorinitials>HW</authorinitials>
-    <affiliation>
-      <shortaffil>sysmocom</shortaffil>
-      <orgname>sysmocom - s.f.m.c. GmbH</orgname>
-      <jobtitle>Managing Director</jobtitle>
-    </affiliation>
-  </author>
-</authorgroup>
-
-<copyright>
-  <year>2013-2016</year>
-  <holder>sysmocom - s.f.m.c. GmbH</holder>
-</copyright>
-
-<legalnotice>
-  <para>
-	Permission is granted to copy, distribute and/or modify this
-	document under the terms of the GNU Free Documentation License,
-	Version 1.3 or any later version published by the Free Software
-	Foundation; with no Invariant Sections, no Front-Cover Texts,
-	and no Back-Cover Texts.  A copy of the license is included in
-	the section entitled "GNU Free Documentation License".
-  </para>
-  <para>
-	The Asciidoc source code of this manual can be found at
-	<ulink url="http://git.osmocom.org/osmo-gsm-manuals/">
-		http://git.osmocom.org/osmo-gsm-manuals/
-	</ulink>
-  </para>
-</legalnotice>
diff --git a/doc/manuals/osmosgsn-usermanual.adoc b/doc/manuals/osmosgsn-usermanual.adoc
deleted file mode 100644
index 610704a..0000000
--- a/doc/manuals/osmosgsn-usermanual.adoc
+++ /dev/null
@@ -1,40 +0,0 @@
-:gfdl-enabled:
-
-OsmoSGSN User Manual
-====================
-Harald Welte <hwelte@sysmocom.de>
-
-
-include::./common/chapters/preface.adoc[]
-
-include::{srcdir}/chapters/overview.adoc[]
-
-include::{srcdir}/chapters/running.adoc[]
-
-include::{srcdir}/chapters/control.adoc[]
-
-include::./common/chapters/vty.adoc[]
-
-include::./common/chapters/logging.adoc[]
-
-include::{srcdir}/chapters/configuration.adoc[]
-
-include::./common/chapters/cs7-config.adoc[]
-
-include::./common/chapters/gb.adoc[]
-
-include::./common/chapters/control_if.adoc[]
-
-include::./common/chapters/oap.adoc[]
-
-include::./common/chapters/gsup.adoc[]
-
-include::{srcdir}/chapters/counters.adoc[]
-
-include::./common/chapters/port_numbers.adoc[]
-
-include::./common/chapters/bibliography.adoc[]
-
-include::./common/chapters/glossary.adoc[]
-
-include::./common/chapters/gfdl.adoc[]
diff --git a/doc/manuals/osmosgsn-vty-reference.xml b/doc/manuals/osmosgsn-vty-reference.xml
deleted file mode 100644
index 82b666a..0000000
--- a/doc/manuals/osmosgsn-vty-reference.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ex:ts=2:sw=42sts=2:et
-  -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
--->
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML 5.0//EN"
-"http://docbook.org/xml/5.0/dtd/docbook.dtd" [
-<!ENTITY chapter-vty      SYSTEM      "./common/chapters/vty.xml" >
-<!ENTITY sections-vty     SYSTEM      "generated/docbook_vty.xml"  >
-]>
-
-<book>
-  <info>
-    <revhistory>
-        <revision>
-            <revnumber>v1</revnumber>
-            <date>13th January 2013</date>
-            <authorinitials>hw</authorinitials>
-            <revremark>Initial</revremark>
-        </revision>
-        <revision>
-            <revnumber>v2</revnumber>
-            <date>5th March 2014</date>
-            <authorinitials>hf</authorinitials>
-            <revremark>Update to match osmo-bsc version 0.13.0-305</revremark>
-        </revision>
-    </revhistory>
-
-    <title>OsmoSGSN VTY Reference</title>
-
-    <copyright>
-      <year>2013-2014</year>
-    </copyright>
-
-    <legalnotice>
-      <para>This work is copyright by <orgname>sysmocom - s.f.m.c. GmbH</orgname>. All rights reserved.
-      </para>
-    </legalnotice>
-  </info>
-
-  <!-- Main chapters-->
-  &chapter-vty;
-</book>
-
diff --git a/doc/manuals/regen_doc.sh b/doc/manuals/regen_doc.sh
index 847b764..e68e7e5 100755
--- a/doc/manuals/regen_doc.sh
+++ b/doc/manuals/regen_doc.sh
@@ -51,27 +51,24 @@
 }
 
 DIR="$(cd "$(dirname "$0")"; pwd)"
+echo $DIR
 cd "$DIR"
 
 require_osmo_interact_vty
 
 interact_vty \
 	"update_vty_reference" \
-	"vty/sgsn_vty_reference.xml" \
-	4245 \
-	osmo-sgsn -c "../examples/osmo-sgsn/osmo-sgsn.cfg"
-
-interact_vty \
-	"update_vty_reference" \
-	"vty-osmogbproxy/gbproxy_vty_reference.xml" \
+	"vty/gbproxy_vty_reference.xml" \
 	4246 \
 	osmo-gbproxy -c "../examples/osmo-gbproxy/osmo-gbproxy.cfg"
 
+sleep 5
+
 interact_vty \
 	"update_counters" \
 	"chapters/counters_generated.adoc" \
-	4245 \
-	osmo-sgsn -c "../examples/osmo-sgsn/osmo-sgsn.cfg"
+	4246 \
+	osmo-gbproxy -c "../examples/osmo-gbproxy/osmo-gbproxy.cfg"
 
 
 echo "Done with all"
diff --git a/doc/manuals/vty-osmogbproxy/gbproxy_vty_additions.xml b/doc/manuals/vty/gbproxy_vty_additions.xml
similarity index 100%
rename from doc/manuals/vty-osmogbproxy/gbproxy_vty_additions.xml
rename to doc/manuals/vty/gbproxy_vty_additions.xml
diff --git a/doc/manuals/vty-osmogbproxy/gbproxy_vty_reference.xml b/doc/manuals/vty/gbproxy_vty_reference.xml
similarity index 78%
rename from doc/manuals/vty-osmogbproxy/gbproxy_vty_reference.xml
rename to doc/manuals/vty/gbproxy_vty_reference.xml
index 1db3c0d..19b04e1 100644
--- a/doc/manuals/vty-osmogbproxy/gbproxy_vty_reference.xml
+++ b/doc/manuals/vty/gbproxy_vty_reference.xml
@@ -7,9 +7,25 @@
         <param name='help' doc='Description of the interactive help system' />
       </params>
     </command>
-    <command id='list'>
+    <command id='list [with-flags]'>
       <params>
         <param name='list' doc='Print command list' />
+        <param name='[with-flags]' doc='Also print the VTY attribute flags' />
+      </params>
+    </command>
+    <command id='show vty-attributes'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='vty-attributes' doc='List of VTY attributes' />
+      </params>
+    </command>
+    <command id='show vty-attributes (application|library|global)'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='vty-attributes' doc='List of VTY attributes' />
+        <param name='application' doc='Application specific attributes only' />
+        <param name='library' doc='Library specific attributes only' />
+        <param name='global' doc='Global attributes only' />
       </params>
     </command>
     <command id='write terminal'>
@@ -67,9 +83,10 @@
         <param name='online-help' doc='Online help' />
       </params>
     </command>
-    <command id='enable'>
+    <command id='enable [expert-mode]'>
       <params>
         <param name='enable' doc='Turn on privileged mode command' />
+        <param name='[expert-mode]' doc='Enable the expert mode (show hidden commands)' />
       </params>
     </command>
     <command id='terminal length &lt;0-512&gt;'>
@@ -188,13 +205,13 @@
         <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 level (|gprs|ns|bssgp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal)'>
+    <command id='logging level (|gprs|ns|obj|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro|lns|lbssgp) (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='gprs' doc='GPRS Packet Service' />
         <param name='ns' doc='GPRS Network Service (NS)' />
-        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
+        <param name='obj' doc='GbProxy object allocation/release' />
         <param name='lglobal' doc='Library-internal global log family' />
         <param name='llapd' doc='LAPD in libosmogsm' />
         <param name='linp' doc='A-bis Intput Subsystem' />
@@ -214,6 +231,8 @@
         <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
         <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
         <param name='lrspro' doc='Remote SIM protocol' />
+        <param name='lns' doc='GPRS NS layer' />
+        <param name='lbssgp' doc='GPRS BSSGP layer' />
         <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' />
@@ -253,12 +272,12 @@
         <param name='force-all' doc='Release any globally forced log level set with &apos;logging level force-all &lt;level&gt;&apos;' />
       </params>
     </command>
-    <command id='logp (|gprs|ns|bssgp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal) .LOGMESSAGE'>
+    <command id='logp (|gprs|ns|obj|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro|lns|lbssgp) (debug|info|notice|error|fatal) .LOGMESSAGE'>
       <params>
         <param name='logp' doc='Print a message on all log outputs; useful for placing markers in test logs' />
         <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='obj' doc='GbProxy object allocation/release' />
         <param name='lglobal' doc='Library-internal global log family' />
         <param name='llapd' doc='LAPD in libosmogsm' />
         <param name='linp' doc='A-bis Intput Subsystem' />
@@ -278,6 +297,8 @@
         <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
         <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
         <param name='lrspro' doc='Remote SIM protocol' />
+        <param name='lns' doc='GPRS NS layer' />
+        <param name='lbssgp' doc='GPRS BSSGP layer' />
         <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' />
@@ -365,10 +386,49 @@
         <param name='rate-counters' doc='Show all rate counters' />
       </params>
     </command>
-    <command id='show gbproxy [stats]'>
+    <command id='show fsm NAME'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm' doc='Show information about finite state machines' />
+        <param name='NAME' doc='Display information about a single named finite state machine' />
+      </params>
+    </command>
+    <command id='show fsm all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm' doc='Show information about finite state machines' />
+        <param name='all' doc='Display a list of all registered finite state machines' />
+      </params>
+    </command>
+    <command id='show fsm-instances NAME'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm-instances' doc='Show information about finite state machine instances' />
+        <param name='NAME' doc='Display a list of all FSM instances of the named finite state machine' />
+      </params>
+    </command>
+    <command id='show fsm-instances all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm-instances' doc='Show information about finite state machine instances' />
+        <param name='all' doc='Display a list of all FSM instances of all finite state machine' />
+      </params>
+    </command>
+    <command id='show gbproxy bvc (bss|sgsn) [stats]'>
       <params>
         <param name='show' doc='Show running system information' />
         <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='bvc' doc='Show BSSGP Virtual Connections' />
+        <param name='bss' doc='Display BSS-side BVCs' />
+        <param name='sgsn' doc='Display SGSN-side BVCs' />
+        <param name='[stats]' doc='Show statistics' />
+      </params>
+    </command>
+    <command id='show gbproxy cell [stats]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='cell' doc='Show GPRS Cell Information' />
         <param name='[stats]' doc='Show statistics' />
       </params>
     </command>
@@ -379,43 +439,41 @@
         <param name='links' doc='Show logical links' />
       </params>
     </command>
-    <command id='show ns'>
+    <command id='show gbproxy tlli-cache'>
       <params>
         <param name='show' doc='Show running system information' />
-        <param name='ns' doc='Display information about the NS protocol' />
+        <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='tlli-cache' doc='Show TLLI cache entries' />
       </params>
     </command>
-    <command id='show ns stats'>
+    <command id='show gbproxy imsi-cache'>
       <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' />
+        <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='imsi-cache' doc='Show IMSI cache entries' />
       </params>
     </command>
-    <command id='show ns persistent'>
+    <command id='show nri all'>
       <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' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='all' doc='Show all SGSNs' />
       </params>
     </command>
-    <command id='show ns (nsei|nsvc) &lt;0-65535&gt; [stats]'>
+    <command id='show nri nsei &lt;0-65535&gt;'>
       <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' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='nsei' doc='Identify SGSN by NSEI' />
+        <param name='&lt;0-65535&gt;' doc='NSEI of the SGSN' />
       </params>
     </command>
-    <command id='logging filter nsvc (nsei|nsvci) &lt;0-65535&gt;'>
+    <command id='logging filter bvc bvci &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='bvc' doc='Filter based on BSSGP VC' />
+        <param name='bvci' doc='Identify BVC by BVCI' />
         <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
       </params>
     </command>
@@ -587,13 +645,13 @@
         <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 level (|gprs|ns|bssgp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal)'>
+    <command id='logging level (|gprs|ns|obj|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro|lns|lbssgp) (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='gprs' doc='GPRS Packet Service' />
         <param name='ns' doc='GPRS Network Service (NS)' />
-        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
+        <param name='obj' doc='GbProxy object allocation/release' />
         <param name='lglobal' doc='Library-internal global log family' />
         <param name='llapd' doc='LAPD in libosmogsm' />
         <param name='linp' doc='A-bis Intput Subsystem' />
@@ -613,6 +671,8 @@
         <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
         <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
         <param name='lrspro' doc='Remote SIM protocol' />
+        <param name='lns' doc='GPRS NS layer' />
+        <param name='lbssgp' doc='GPRS BSSGP layer' />
         <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' />
@@ -652,12 +712,12 @@
         <param name='force-all' doc='Release any globally forced log level set with &apos;logging level force-all &lt;level&gt;&apos;' />
       </params>
     </command>
-    <command id='logp (|gprs|ns|bssgp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal) .LOGMESSAGE'>
+    <command id='logp (|gprs|ns|obj|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro|lns|lbssgp) (debug|info|notice|error|fatal) .LOGMESSAGE'>
       <params>
         <param name='logp' doc='Print a message on all log outputs; useful for placing markers in test logs' />
         <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='obj' doc='GbProxy object allocation/release' />
         <param name='lglobal' doc='Library-internal global log family' />
         <param name='llapd' doc='LAPD in libosmogsm' />
         <param name='linp' doc='A-bis Intput Subsystem' />
@@ -677,6 +737,8 @@
         <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
         <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
         <param name='lrspro' doc='Remote SIM protocol' />
+        <param name='lns' doc='GPRS NS layer' />
+        <param name='lbssgp' doc='GPRS BSSGP layer' />
         <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' />
@@ -764,10 +826,61 @@
         <param name='rate-counters' doc='Show all rate counters' />
       </params>
     </command>
-    <command id='show gbproxy [stats]'>
+    <command id='stats report'>
+      <params>
+        <param name='stats' doc='Stats related commands' />
+        <param name='report' doc='Manurally trigger reporting of stats' />
+      </params>
+    </command>
+    <command id='stats reset'>
+      <params>
+        <param name='stats' doc='Stats related commands' />
+        <param name='reset' doc='Reset all stats' />
+      </params>
+    </command>
+    <command id='show fsm NAME'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm' doc='Show information about finite state machines' />
+        <param name='NAME' doc='Display information about a single named finite state machine' />
+      </params>
+    </command>
+    <command id='show fsm all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm' doc='Show information about finite state machines' />
+        <param name='all' doc='Display a list of all registered finite state machines' />
+      </params>
+    </command>
+    <command id='show fsm-instances NAME'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm-instances' doc='Show information about finite state machine instances' />
+        <param name='NAME' doc='Display a list of all FSM instances of the named finite state machine' />
+      </params>
+    </command>
+    <command id='show fsm-instances all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='fsm-instances' doc='Show information about finite state machine instances' />
+        <param name='all' doc='Display a list of all FSM instances of all finite state machine' />
+      </params>
+    </command>
+    <command id='show gbproxy bvc (bss|sgsn) [stats]'>
       <params>
         <param name='show' doc='Show running system information' />
         <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='bvc' doc='Show BSSGP Virtual Connections' />
+        <param name='bss' doc='Display BSS-side BVCs' />
+        <param name='sgsn' doc='Display SGSN-side BVCs' />
+        <param name='[stats]' doc='Show statistics' />
+      </params>
+    </command>
+    <command id='show gbproxy cell [stats]'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='cell' doc='Show GPRS Cell Information' />
         <param name='[stats]' doc='Show statistics' />
       </params>
     </command>
@@ -778,17 +891,55 @@
         <param name='links' doc='Show logical links' />
       </params>
     </command>
+    <command id='show gbproxy tlli-cache'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='tlli-cache' doc='Show TLLI cache entries' />
+      </params>
+    </command>
+    <command id='show gbproxy imsi-cache'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='gbproxy' doc='Display information about the Gb proxy' />
+        <param name='imsi-cache' doc='Show IMSI cache entries' />
+      </params>
+    </command>
+    <command id='show nri all'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='all' doc='Show all SGSNs' />
+      </params>
+    </command>
+    <command id='show nri nsei &lt;0-65535&gt;'>
+      <params>
+        <param name='show' doc='Show running system information' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='nsei' doc='Identify SGSN by NSEI' />
+        <param name='&lt;0-65535&gt;' doc='NSEI of the SGSN' />
+      </params>
+    </command>
+    <command id='logging filter bvc 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 VC' />
+        <param name='bvci' doc='Identify BVC by BVCI' />
+        <param name='&lt;0-65535&gt;' doc='Numeric identifier' />
+      </params>
+    </command>
     <command id='delete-gbproxy-peer &lt;0-65534&gt; bvci &lt;2-65534&gt;'>
       <params>
-        <param name='delete-gbproxy-peer' doc='Delete a GBProxy peer by NSEI and optionally BVCI' />
+        <param name='delete-gbproxy-peer' doc='Delete a GBProxy bvc by NSEI and optionally BVCI' />
         <param name='&lt;0-65534&gt;' doc='NSEI number' />
-        <param name='bvci' doc='Only delete peer with a matching BVCI' />
+        <param name='bvci' doc='Only delete bvc with a matching BVCI' />
         <param name='&lt;2-65534&gt;' doc='BVCI number' />
       </params>
     </command>
     <command id='delete-gbproxy-peer &lt;0-65534&gt; (only-bvc|only-nsvc|all) [dry-run]'>
       <params>
-        <param name='delete-gbproxy-peer' doc='Delete a GBProxy peer by NSEI and optionally BVCI' />
+        <param name='delete-gbproxy-peer' doc='Delete a GBProxy bvc by NSEI and optionally BVCI' />
         <param name='&lt;0-65534&gt;' doc='NSEI number' />
         <param name='only-bvc' doc='Only delete BSSGP connections (BVC)' />
         <param name='only-nsvc' doc='Only delete dynamic NS connections (NS-VC)' />
@@ -796,75 +947,6 @@
         <param name='[dry-run]' doc='Show what would be deleted instead of actually deleting' />
       </params>
     </command>
-    <command id='delete-gbproxy-link &lt;0-65534&gt; (tlli|imsi|sgsn-nsei) IDENT'>
-      <params>
-        <param name='delete-gbproxy-link' doc='Delete a GBProxy logical link entry by NSEI and identification' />
-        <param name='&lt;0-65534&gt;' doc='NSEI number' />
-        <param name='tlli' doc='Delete entries with a matching TLLI (hex)' />
-        <param name='imsi' doc='Delete entries with a matching IMSI' />
-        <param name='sgsn-nsei' doc='Delete entries with a matching SGSN NSEI' />
-        <param name='IDENT' doc='Identification to match' />
-      </params>
-    </command>
-    <command id='delete-gbproxy-link &lt;0-65534&gt; (stale|de-registered)'>
-      <params>
-        <param name='delete-gbproxy-link' doc='Delete a GBProxy logical link entry by NSEI and identification' />
-        <param name='&lt;0-65534&gt;' doc='NSEI number' />
-        <param name='stale' doc='Delete stale entries' />
-        <param name='de-registered' doc='Delete de-registered entries' />
-      </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>
   </node>
   <node id='config'>
     <name>config</name>
@@ -1052,6 +1134,20 @@
         <param name='syslog' doc='Logging via syslog' />
       </params>
     </command>
+    <command id='log systemd-journal [raw]'>
+      <params>
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='systemd-journal' doc='Logging to systemd-journal' />
+        <param name='[raw]' doc='Offload rendering of the meta information (location, category) to systemd' />
+      </params>
+    </command>
+    <command id='no log systemd-journal'>
+      <params>
+        <param name='no' doc='Negate a command or set its defaults' />
+        <param name='log' doc='Configure logging sub-system' />
+        <param name='systemd-journal' doc='Logging to systemd-journal' />
+      </params>
+    </command>
     <command id='log gsmtap [HOSTNAME]'>
       <params>
         <param name='log' doc='Configure logging sub-system' />
@@ -1089,11 +1185,11 @@
         <param name='log' doc='Report to the logger' />
       </params>
     </command>
-    <command id='stats interval &lt;1-65535&gt;'>
+    <command id='stats interval &lt;0-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' />
+        <param name='&lt;0-65535&gt;' doc='Interval in seconds (0 disables the reporting interval)' />
       </params>
     </command>
     <command id='gbproxy'>
@@ -1101,9 +1197,11 @@
         <param name='gbproxy' doc='Configure the Gb proxy' />
       </params>
     </command>
-    <command id='ns'>
+    <command id='sgsn nsei &lt;0-65534&gt;'>
       <params>
-        <param name='ns' doc='Configure the GPRS Network Service' />
+        <param name='sgsn' doc='Configure the SGSN' />
+        <param name='nsei' doc='NSEI to be used in the connection with the SGSN' />
+        <param name='&lt;0-65534&gt;' doc='The NSEI' />
       </params>
     </command>
   </node>
@@ -1181,13 +1279,13 @@
         <param name='[last]' doc='Log source file info at the end of a log line. If omitted, log source file info just before the log text.' />
       </params>
     </command>
-    <command id='logging level (|gprs|ns|bssgp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal)'>
+    <command id='logging level (|gprs|ns|obj|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro|lns|lbssgp) (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='gprs' doc='GPRS Packet Service' />
         <param name='ns' doc='GPRS Network Service (NS)' />
-        <param name='bssgp' doc='GPRS BSS Gateway Protocol (BSSGP)' />
+        <param name='obj' doc='GbProxy object allocation/release' />
         <param name='lglobal' doc='Library-internal global log family' />
         <param name='llapd' doc='LAPD in libosmogsm' />
         <param name='linp' doc='A-bis Intput Subsystem' />
@@ -1207,6 +1305,8 @@
         <param name='lmgcp' doc='libosmo-mgcp Media Gateway Control Protocol' />
         <param name='ljibuf' doc='libosmo-netif Jitter Buffer' />
         <param name='lrspro' doc='Remote SIM protocol' />
+        <param name='lns' doc='GPRS NS layer' />
+        <param name='lbssgp' doc='GPRS BSSGP layer' />
         <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' />
@@ -1246,16 +1346,6 @@
         <param name='force-all' doc='Release any globally forced log level set with &apos;logging level force-all &lt;level&gt;&apos;' />
       </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>
   </node>
   <node id='config-stats'>
     <name>config-stats</name>
@@ -1325,6 +1415,12 @@
         <param name='disable' doc='Disable the reporter' />
       </params>
     </command>
+    <command id='flush-period &lt;0-65535&gt;'>
+      <params>
+        <param name='flush-period' doc='Configure stats sub-system' />
+        <param name='&lt;0-65535&gt;' doc='Send all stats even if they have not changed (i.e. force the flush)every N-th reporting interval. Set to 0 to disable regular flush (default).' />
+      </params>
+    </command>
   </node>
   <node id='config-line'>
     <name>config-line</name>
@@ -1347,280 +1443,95 @@
       </params>
     </command>
   </node>
-  <node id='config-ns'>
-    <name>config-ns</name>
-    <command id='nse &lt;0-65535&gt; nsvci &lt;0-65534&gt;'>
+  <node id='config-gbproxy'>
+    <name>config-gbproxy</name>
+    <command id='pool bvc-flow-control-ratio &lt;1-100&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)' />
+        <param name='pool' doc='SGSN Pool related configuration' />
+        <param name='bvc-flow-control-ratio' doc='Ratio of BSS-advertised bucket size + leak rate advertised to each SGSN' />
+        <param name='&lt;1-100&gt;' doc='Ratio of BSS-advertised bucket size + leak rate advertised to each SGSN (Percent)' />
       </params>
     </command>
-    <command id='nse &lt;0-65535&gt; remote-ip A.B.C.D'>
+    <command id='nri bitlen &lt;0-15&gt;'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <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' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='bitlen' doc='Set number of bits that an NRI has, to extract from TMSI identities (always starting just after the TMSI&apos;s most significant octet).' />
+        <param name='&lt;0-15&gt;' doc='bit count (0 disables) pooling)' />
       </params>
     </command>
-    <command id='nse &lt;0-65535&gt; remote-port &lt;0-65535&gt;'>
+    <command id='nri null add &lt;0-32767&gt; [&lt;0-32767&gt;]'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <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' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='null' doc='Define NULL-NRI values that cause re-assignment of an MS to a different SGSN, for SGSN pooling.' />
+        <param name='add' doc='Add NULL-NRI value (or range)' />
+        <param name='&lt;0-32767&gt;' doc='First value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos;.' />
+        <param name='[&lt;0-32767&gt;]' doc='Last value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos; and be larger than the first value; if omitted, apply only the first value.' />
       </params>
     </command>
-    <command id='nse &lt;0-65535&gt; fr-dlci &lt;16-1007&gt;'>
+    <command id='nri null del &lt;0-32767&gt; [&lt;0-32767&gt;]'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <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|tsns-prov) &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='tsns-prov' doc='SNS Provision Timer (Tsns-prov) timeout' />
-        <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' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='null' doc='Define NULL-NRI values that cause re-assignment of an MS to a different SGSN, for SGSN pooling.' />
+        <param name='del' doc='Remove NRI value or range from the NRI mapping for this MSC' />
+        <param name='&lt;0-32767&gt;' doc='First value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos;.' />
+        <param name='[&lt;0-32767&gt;]' doc='Last value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos; and be larger than the first value; if omitted, apply only the first value.' />
       </params>
     </command>
   </node>
-  <node id='config-gbproxy'>
-    <name>config-gbproxy</name>
-    <command id='sgsn nsei &lt;0-65534&gt;'>
+  <node id='config-sgsn'>
+    <name>config-sgsn</name>
+    <command id='name NAME'>
       <params>
-        <param name='sgsn' doc='SGSN information' />
-        <param name='nsei' doc='NSEI to be used in the connection with the SGSN' />
-        <param name='&lt;0-65534&gt;' doc='The NSEI' />
+        <param name='name' doc='Configure the SGSN' />
+        <param name='NAME' doc='Name the SGSN' />
       </params>
     </command>
-    <command id='core-mobile-country-code &lt;1-999&gt;'>
+    <command id='allow-attach'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <params>
-        <param name='core-mobile-country-code' doc='Use this country code for the core network' />
-        <param name='&lt;1-999&gt;' doc='MCC value' />
+        <param name='allow-attach' doc='Allow this SGSN to attach new subscribers (default).' />
       </params>
     </command>
-    <command id='core-mobile-network-code &lt;1-999&gt;'>
-      <params>
-        <param name='core-mobile-network-code' doc='Use this network code for the core network' />
-        <param name='&lt;1-999&gt;' doc='NCC value' />
-      </params>
-    </command>
-    <command id='match-imsi (patching|routing) .REGEXP'>
-      <params>
-        <param name='match-imsi' doc='Restrict actions to certain IMSIs' />
-        <param name='patching' doc='Patch MS related information elements on match only' />
-        <param name='routing' doc='Route to the secondary SGSN on match only' />
-        <param name='.REGEXP' doc='Regular expression for the IMSI match' />
-      </params>
-    </command>
-    <command id='core-access-point-name (APN|none)'>
-      <params>
-        <param name='core-access-point-name' doc='Use this access point name (APN) for the backbone' />
-        <param name='APN' doc='Replace APN by this string' />
-        <param name='none' doc='Remove APN' />
-      </params>
-    </command>
-    <command id='secondary-sgsn nsei &lt;0-65534&gt;'>
-      <params>
-        <param name='secondary-sgsn' doc='Route matching LLC connections to a second SGSN (Experimental)' />
-        <param name='nsei' doc='NSEI to be used in the connection with the SGSN' />
-        <param name='&lt;0-65534&gt;' doc='The NSEI' />
-      </params>
-    </command>
-    <command id='patch-ptmsi'>
-      <params>
-        <param name='patch-ptmsi' doc='Patch P-TMSI/TLLI' />
-      </params>
-    </command>
-    <command id='acquire-imsi'>
-      <params>
-        <param name='acquire-imsi' doc='Acquire the IMSI before establishing a LLC connection (Experimental)' />
-      </params>
-    </command>
-    <command id='link-list clean-stale-timer &lt;1-999999&gt;'>
-      <params>
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='clean-stale-timer' doc='Periodic timer to clean stale links' />
-        <param name='&lt;1-999999&gt;' doc='Frequency at which the periodic timer is fired (in seconds)' />
-      </params>
-    </command>
-    <command id='link-list max-age &lt;1-999999&gt;'>
-      <params>
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='max-age' doc='Limit maximum age' />
-        <param name='&lt;1-999999&gt;' doc='Maximum age in seconds' />
-      </params>
-    </command>
-    <command id='link-list max-length &lt;1-99999&gt;'>
-      <params>
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='max-length' doc='Limit list length' />
-        <param name='&lt;1-99999&gt;' doc='Maximum number of logical links in the list' />
-      </params>
-    </command>
-    <command id='link-list keep-mode (never|re-attach|identified|always)'>
-      <params>
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='keep-mode' doc='How to keep entries for detached logical links' />
-        <param name='never' doc='Discard entry immediately after detachment' />
-        <param name='re-attach' doc='Keep entry if a re-attachment has be requested' />
-        <param name='identified' doc='Keep entry if it associated with an IMSI' />
-        <param name='always' doc='Don&apos;t discard entries after detachment' />
-      </params>
-    </command>
-    <command id='link stored-msgs-max-length &lt;1-99999&gt;'>
-      <params>
-        <param name='link' doc='Set TLLI parameters' />
-        <param name='stored-msgs-max-length' doc='Limit list length' />
-        <param name='&lt;1-99999&gt;' doc='Maximum number of msgb stored in the logical link waiting to acquire its IMSI' />
-      </params>
-    </command>
-    <command id='no core-mobile-country-code'>
+    <command id='no allow-attach'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <params>
         <param name='no' doc='Negate a command or set its defaults' />
-        <param name='core-mobile-country-code' doc='Use this country code for the core network' />
+        <param name='allow-attach' doc='Do not assign new subscribers to this MSC. Useful if an MSC in an MSC pool is configured to off-load subscribers. The MSC will still be operational for already IMSI-Attached subscribers, but the NAS node selection function will skip this MSC for new subscribers' />
       </params>
     </command>
-    <command id='no core-mobile-network-code'>
+    <command id='nri add &lt;0-32767&gt; [&lt;0-32767&gt;]'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='core-mobile-network-code' doc='Use this network code for the core network' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='add' doc='Add NRI value or range to the NRI mapping for this MSC' />
+        <param name='&lt;0-32767&gt;' doc='First value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos;.' />
+        <param name='[&lt;0-32767&gt;]' doc='Last value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos; and be larger than the first value; if omitted, apply only the first value.' />
       </params>
     </command>
-    <command id='no match-imsi'>
+    <command id='nri del &lt;0-32767&gt; [&lt;0-32767&gt;]'>
+      <attributes scope='global'>
+        <attribute doc='This command applies immediately' flag='!' />
+      </attributes>
       <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='match-imsi' doc='Restrict actions to certain IMSIs' />
-      </params>
-    </command>
-    <command id='no core-access-point-name'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='core-access-point-name' doc='Use this access point name (APN) for the backbone' />
-      </params>
-    </command>
-    <command id='no secondary-sgsn'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='secondary-sgsn' doc='Route matching LLC connections to a second SGSN (Experimental)' />
-      </params>
-    </command>
-    <command id='no patch-ptmsi'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='patch-ptmsi' doc='Patch P-TMSI/TLLI' />
-      </params>
-    </command>
-    <command id='no acquire-imsi'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='acquire-imsi' doc='Acquire the IMSI before establishing a LLC connection (Experimental)' />
-      </params>
-    </command>
-    <command id='no link-list clean-stale-timer'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='clean-stale-timer' doc='Periodic timer to clean stale links' />
-      </params>
-    </command>
-    <command id='no link-list max-age'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='max-age' doc='Limit maximum age' />
-      </params>
-    </command>
-    <command id='no link-list max-length'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='link-list' doc='Set TLLI list parameters' />
-        <param name='max-length' doc='Limit list length' />
-      </params>
-    </command>
-    <command id='no link stored-msgs-max-length'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='link' doc='Set TLLI parameters' />
-        <param name='stored-msgs-max-length' doc='Limit list length' />
+        <param name='nri' doc='Mapping of Network Resource Indicators to this SGSN, for SGSN pooling' />
+        <param name='del' doc='Remove NRI value or range from the NRI mapping for this MSC' />
+        <param name='&lt;0-32767&gt;' doc='First value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos;.' />
+        <param name='[&lt;0-32767&gt;]' doc='Last value of the NRI value range, should not surpass the configured &apos;nri bitlen&apos; and be larger than the first value; if omitted, apply only the first value.' />
       </params>
     </command>
   </node>
diff --git a/doc/manuals/vty/sgsn_vty_additions.xml b/doc/manuals/vty/sgsn_vty_additions.xml
deleted file mode 100644
index 660b695..0000000
--- a/doc/manuals/vty/sgsn_vty_additions.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<vtydoc xmlns='urn:osmocom:xml:libosmocore:vty:doc:1.0'>
-    <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
deleted file mode 100644
index 8ffc607..0000000
--- a/doc/manuals/vty/sgsn_vty_reference.xml
+++ /dev/null
@@ -1,2677 +0,0 @@
-<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 [PATH]'>
-      <params>
-        <param name='write' doc='Write running configuration to memory, network, or terminal' />
-        <param name='file' doc='Write to configuration file' />
-        <param name='[PATH]' doc='Set file path to store the config, or replace if already exists' />
-      </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='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) [last]'>
-      <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' />
-        <param name='[last]' doc='Log source file info at the end of a log line. If omitted, log source file info just before the log text.' />
-      </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 level (|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|gtp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (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='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='gtp' doc='GPRS Tunnelling Protocol (GTP)' />
-        <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='lrspro' doc='Remote SIM protocol' />
-        <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 level set-all (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='set-all' doc='Once-off set all categories to the given log level. There is no single command to take back these changes -- each category is set to the given level, period.' />
-        <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 level force-all (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='force-all' doc='Globally force all logging categories to a specific level. This is released by the &apos;no logging level force-all&apos; command. Note: any &apos;logging level &lt;category&gt; &lt;level&gt;&apos; commands will have no visible effect after this, until the forced level is released.' />
-        <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='no logging level force-all'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='logging' doc='Configure logging' />
-        <param name='level' doc='Set the log level for a specified category' />
-        <param name='force-all' doc='Release any globally forced log level set with &apos;logging level force-all &lt;level&gt;&apos;' />
-      </params>
-    </command>
-    <command id='logp (|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|gtp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal) .LOGMESSAGE'>
-      <params>
-        <param name='logp' doc='Print a message on all log outputs; useful for placing markers in test logs' />
-        <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='gtp' doc='GPRS Tunnelling Protocol (GTP)' />
-        <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='lrspro' doc='Remote SIM protocol' />
-        <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' />
-        <param name='.LOGMESSAGE' doc='Arbitrary message to log on given category and log level' />
-      </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 rate-counters'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='rate-counters' doc='Show all rate 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 timer [TNNNN]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='timer' doc='Show timers' />
-        <param name='[TNNNN]' doc='T- or X-timer-number -- 3GPP compliant timer number of the format &apos;1234&apos; or &apos;T1234&apos; or &apos;t1234&apos;; Osmocom-specific timer number of the format: &apos;X1234&apos; or &apos;x1234&apos;.' />
-      </params>
-    </command>
-    <command id='show cpu-sched threads'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='cpu-sched' doc='Show Sched section information' />
-        <param name='threads' doc='Show information about running threads)' />
-      </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 config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='cs7' doc='ITU-T Signaling System 7' />
-        <param name='config' doc='Currently running cs7 configuration' />
-      </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 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' doc='Signalling Connection Control Part' />
-        <param name='addressbook' doc='List all SCCP addressbook entries' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp 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='sccp' doc='Signalling Connection Control Part' />
-        <param name='users' doc='Show List of SCCP Users registered' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp ssn &lt;0-65535&gt;'>
-      <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' doc='Signalling Connection Control Part' />
-        <param name='ssn' doc='Find an SCCP User registered for the given SSN' />
-        <param name='&lt;0-65535&gt;' doc='Subsystem Number (SSN)' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp connections'>
-      <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' doc='Signalling Connection Control Part' />
-        <param name='connections' doc='Show List of active SCCP connections' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp timers'>
-      <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' doc='Signaling Connection Control Part' />
-        <param name='timers' doc='Show List of SCCP timers' />
-      </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='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) [last]'>
-      <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' />
-        <param name='[last]' doc='Log source file info at the end of a log line. If omitted, log source file info just before the log text.' />
-      </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 level (|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|gtp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (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='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='gtp' doc='GPRS Tunnelling Protocol (GTP)' />
-        <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='lrspro' doc='Remote SIM protocol' />
-        <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 level set-all (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='set-all' doc='Once-off set all categories to the given log level. There is no single command to take back these changes -- each category is set to the given level, period.' />
-        <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 level force-all (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='force-all' doc='Globally force all logging categories to a specific level. This is released by the &apos;no logging level force-all&apos; command. Note: any &apos;logging level &lt;category&gt; &lt;level&gt;&apos; commands will have no visible effect after this, until the forced level is released.' />
-        <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='no logging level force-all'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='logging' doc='Configure logging' />
-        <param name='level' doc='Set the log level for a specified category' />
-        <param name='force-all' doc='Release any globally forced log level set with &apos;logging level force-all &lt;level&gt;&apos;' />
-      </params>
-    </command>
-    <command id='logp (|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|gtp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (debug|info|notice|error|fatal) .LOGMESSAGE'>
-      <params>
-        <param name='logp' doc='Print a message on all log outputs; useful for placing markers in test logs' />
-        <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='gtp' doc='GPRS Tunnelling Protocol (GTP)' />
-        <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='lrspro' doc='Remote SIM protocol' />
-        <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' />
-        <param name='.LOGMESSAGE' doc='Arbitrary message to log on given category and log level' />
-      </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 rate-counters'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='rate-counters' doc='Show all rate counters' />
-      </params>
-    </command>
-    <command id='stats report'>
-      <params>
-        <param name='stats' doc='Stats related commands' />
-        <param name='report' doc='Manurally trigger reporting of stats' />
-      </params>
-    </command>
-    <command id='stats reset'>
-      <params>
-        <param name='stats' doc='Stats related commands' />
-        <param name='reset' doc='Reset all stats' />
-      </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 timer [TNNNN]'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='timer' doc='Show timers' />
-        <param name='[TNNNN]' doc='T- or X-timer-number -- 3GPP compliant timer number of the format &apos;1234&apos; or &apos;T1234&apos; or &apos;t1234&apos;; Osmocom-specific timer number of the format: &apos;X1234&apos; or &apos;x1234&apos;.' />
-      </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 cpu-sched threads'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='cpu-sched' doc='Show Sched section information' />
-        <param name='threads' doc='Show information about running threads)' />
-      </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 config'>
-      <params>
-        <param name='show' doc='Show running system information' />
-        <param name='cs7' doc='ITU-T Signaling System 7' />
-        <param name='config' doc='Currently running cs7 configuration' />
-      </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 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' doc='Signalling Connection Control Part' />
-        <param name='addressbook' doc='List all SCCP addressbook entries' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp 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='sccp' doc='Signalling Connection Control Part' />
-        <param name='users' doc='Show List of SCCP Users registered' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp ssn &lt;0-65535&gt;'>
-      <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' doc='Signalling Connection Control Part' />
-        <param name='ssn' doc='Find an SCCP User registered for the given SSN' />
-        <param name='&lt;0-65535&gt;' doc='Subsystem Number (SSN)' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp connections'>
-      <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' doc='Signalling Connection Control Part' />
-        <param name='connections' doc='Show List of active SCCP connections' />
-      </params>
-    </command>
-    <command id='show cs7 instance &lt;0-15&gt; sccp timers'>
-      <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' doc='Signaling Connection Control Part' />
-        <param name='timers' doc='Show List of SCCP timers' />
-      </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;0-65535&gt;'>
-      <params>
-        <param name='stats' doc='Configure stats sub-system' />
-        <param name='interval' doc='Set the reporting interval' />
-        <param name='&lt;0-65535&gt;' doc='Interval in seconds (0 disables the reporting interval)' />
-      </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='cpu-sched'>
-      <params>
-        <param name='cpu-sched' doc='Configure CPU Scheduler related settings' />
-      </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) [last]'>
-      <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' />
-        <param name='[last]' doc='Log source file info at the end of a log line. If omitted, log source file info just before the log text.' />
-      </params>
-    </command>
-    <command id='logging level (|mm|pag|meas|ref|gprs|ns|bssgp|llc|sndcp|slhc|ranap|sua|v42bis|gtp|lglobal|llapd|linp|lmux|lmi|lmib|lsms|lctrl|lgtp|lstats|lgsup|loap|lss7|lsccp|lsua|lm3ua|lmgcp|ljibuf|lrspro) (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='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='gtp' doc='GPRS Tunnelling Protocol (GTP)' />
-        <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='lrspro' doc='Remote SIM protocol' />
-        <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 level set-all (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='set-all' doc='Once-off set all categories to the given log level. There is no single command to take back these changes -- each category is set to the given level, period.' />
-        <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 level force-all (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='force-all' doc='Globally force all logging categories to a specific level. This is released by the &apos;no logging level force-all&apos; command. Note: any &apos;logging level &lt;category&gt; &lt;level&gt;&apos; commands will have no visible effect after this, until the forced level is released.' />
-        <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='no logging level force-all'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='logging' doc='Configure logging' />
-        <param name='level' doc='Set the log level for a specified category' />
-        <param name='force-all' doc='Release any globally forced log level set with &apos;logging level force-all &lt;level&gt;&apos;' />
-      </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>
-    <command id='flush-period &lt;0-65535&gt;'>
-      <params>
-        <param name='flush-period' doc='Configure stats sub-system' />
-        <param name='&lt;0-65535&gt;' doc='Send all stats even if they have not changed (i.e. force the flush)every N-th reporting interval. Set to 0 to disable regular flush (default).' />
-      </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 [&lt;0-65535&gt;]'>
-      <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)' />
-        <param name='[&lt;0-65535&gt;]' doc='Local TCP port number' />
-      </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|tsns-prov) &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='tsns-prov' doc='SNS Provision Timer (Tsns-prov) timeout' />
-        <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 udp use-reset-block-unblock (enabled|disabled)'>
-      <params>
-        <param name='encapsulation' doc='NS encapsulation options' />
-        <param name='udp' doc='NS over UDP Encapsulation' />
-        <param name='use-reset-block-unblock' doc='Use NS-{RESET,BLOCK,UNBLOCK} procedures in violation of 3GPP TS 48.016' />
-        <param name='enabled' doc='Enable NS-{RESET,BLOCK,UNBLOCK}' />
-        <param name='disabled' doc='Disable NS-{RESET,BLOCK,UNBLOCK}' />
-      </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='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>
-    <command id='sccp-timer (conn_est|ias|iar|rel|repeat_rel|int|guard|reset|reassembly) &lt;1-999999&gt;'>
-      <params>
-        <param name='sccp-timer' doc='Configure SCCP timer values, see ITU-T Q.714' />
-        <param name='conn_est' doc='Waiting for connection confirm message, 1 to 2 minutes (default: 60)' />
-        <param name='ias' doc='Send keep-alive: on an idle connection, delay before sending an Idle Timer message, 5 to 10 minutes (default: 420)' />
-        <param name='iar' doc='Receive keep-alive: on an idle connection, delay until considering a connection as stale, 11 to 21 minutes (default: 900)' />
-        <param name='rel' doc='Waiting for release complete message, 10 to 20 seconds (default: 10)' />
-        <param name='repeat_rel' doc='Waiting for release complete message; or to repeat sending released message after the initial expiry, 10 to 20 seconds (default: 10)' />
-        <param name='int' doc='Waiting for release complete message; or to release connection resources, freeze the LRN and alert a maintenance function after the initial expiry, extending to 1 minute (default: 60)' />
-        <param name='guard' doc='Waiting to resume normal procedure for temporary connection sections during the restart procedure, 23 to 25 minutes (default: 1380)' />
-        <param name='reset' doc='Waiting to release temporary connection section or alert maintenance function after reset request message is sent, 10 to 20 seconds (default: 10)' />
-        <param name='reassembly' doc='Waiting to receive all the segments of the remaining segments, single segmented message after receiving the first segment, 10 to 20 seconds (default: 10)' />
-        <param name='&lt;1-999999&gt;' doc='Timer value, in seconds' />
-      </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='no traffic-mode'>
-      <params>
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='traffic-mode' doc='Remove explicit traffic mode of operation of this AS' />
-      </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>
-    <command id='point-code override patch-sccp (disabled|both)'>
-      <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='patch-sccp' doc='Patch point code values into SCCP called/calling address' />
-        <param name='disabled' doc='Don&apos;t patch any point codes into SCCP called/calling address' />
-        <param name='both' doc='Patch both origin and destination point codes into SCCP called/calling address' />
-      </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='role (sg|asp|ipsp)'>
-      <params>
-        <param name='role' doc='Specify the xUA role for this ASP' />
-        <param name='sg' doc='SG (Signaling Gateway)' />
-        <param name='asp' doc='ASP (Application Server Process)' />
-        <param name='ipsp' doc='IPSP (IP Signalling Point)' />
-      </params>
-    </command>
-    <command id='sctp-role (client|server)'>
-      <params>
-        <param name='sctp-role' doc='Specify the SCTP role for this ASP' />
-        <param name='client' doc='Operate as SCTP client; connect to a server' />
-        <param name='server' doc='Operate as SCTP server; wait for client connections' />
-      </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-cpu-sched'>
-    <name>config-cpu-sched</name>
-    <command id='policy rr &lt;1-32&gt;'>
-      <params>
-        <param name='policy' doc='Set the scheduling policy to use for the process' />
-        <param name='rr' doc='Use the SCHED_RR real-time scheduling algorithm' />
-        <param name='&lt;1-32&gt;' doc='Set the SCHED_RR real-time priority' />
-      </params>
-    </command>
-    <command id='cpu-affinity (self|all|&lt;0-4294967295&gt;|THREADNAME) CPUHEXMASK [delay]'>
-      <params>
-        <param name='cpu-affinity' doc='Set CPU affinity mask on a (group of) thread(s)' />
-        <param name='self' doc='Set CPU affinity mask on thread running the VTY' />
-        <param name='all' doc='Set CPU affinity mask on all process&apos; threads' />
-        <param name='&lt;0-4294967295&gt;' doc='Set CPU affinity mask on a thread with specified PID' />
-        <param name='THREADNAME' doc='Set CPU affinity mask on a thread with specified thread name' />
-        <param name='CPUHEXMASK' doc='CPU affinity mask' />
-        <param name='[delay]' doc='If set, delay applying the affinity mask now and let the app handle it at a later point' />
-      </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='ggsn &lt;0-255&gt; echo-interval &lt;1-36000&gt;'>
-      <params>
-        <param name='ggsn' doc='Configure the GGSN information' />
-        <param name='&lt;0-255&gt;' doc='GGSN Number' />
-        <param name='echo-interval' doc='Send an echo request to this static GGSN every interval.' />
-        <param name='&lt;1-36000&gt;' doc='Interval between echo requests in seconds.' />
-      </params>
-    </command>
-    <command id='ggsn &lt;0-255&gt; no echo-interval'>
-      <params>
-        <param name='ggsn' doc='Configure the GGSN information' />
-        <param name='&lt;0-255&gt;' doc='GGSN Number' />
-        <param name='no' doc='Negate a command or set its defaults' />
-        <param name='echo-interval' doc='Send an echo request to this static GGSN every interval.' />
-      </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='authentication (optional|required)'>
-      <params>
-        <param name='authentication' doc='Whether to enforce MS authentication in GERAN (only with auth-policy remote)' />
-        <param name='optional' doc='Allow MS to attach via GERAN without authentication (default and only possible value for non-remote auth-policy)' />
-        <param name='required' doc='Always require authentication (only available for auth-policy remote, default with that auth-policy)' />
-      </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 ipa-name NAME'>
-      <params>
-        <param name='gsup' doc='GSUP Parameters' />
-        <param name='ipa-name' doc='Set the IPA name of this SGSN' />
-        <param name='NAME' doc='A unique name for this SGSN. For example: PLMN + redundancy server number: SGSN-901-70-0. This name is used for GSUP routing and must be set if more than one SGSN is connected to the network. The default is &apos;SGSN-00-00-00-00-00-00&apos;.' />
-      </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 [TNNNN] [(&lt;0-2147483647&gt;|default)]'>
-      <params>
-        <param name='timer' doc='Configure or show timers' />
-        <param name='[TNNNN]' doc='T- or X-timer-number -- 3GPP compliant timer number of the format &apos;1234&apos; or &apos;T1234&apos; or &apos;t1234&apos;; Osmocom-specific timer number of the format: &apos;X1234&apos; or &apos;x1234&apos;.' />
-        <param name='[&lt;0-2147483647&gt;]' doc='New timer value' />
-        <param name='[default]' doc='Set to default timer value' />
-      </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 compression 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 compression 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 compression 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 compression scheme' />
-        <param name='passive' doc='Compression is available on request' />
-      </params>
-    </command>
-    <command id='cs7-instance-iu &lt;0-15&gt;'>
-      <params>
-        <param name='cs7-instance-iu' doc='Set SS7 to be used by the Iu-Interface.' />
-        <param name='&lt;0-15&gt;' doc='SS7 instance reference number (default: 0)' />
-      </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>
