<revhistory>
  <revision>
    <revnumber>0.1</revnumber>
    <date>31 May 2017</date>
    <authorinitials>Harald Welte</authorinitials>
    <revremark>
       Initial version of the proposal for internal discussion.
    </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>2017</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 the Invariant Sections being just 'Foreword',
	'Acknowledgements' and 'Preface', with 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>
