#
# spec file for package osmo-msc
#
# Copyright (c) 2017, Martin Hauke <mardnh@gmx.de>
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.

## Disable LTO for now since it breaks compilation of the tests
## https://osmocom.org/issues/4115
%define _lto_cflags %{nil}

%define with_iu 1
Name:           osmo-msc
Version:        @VERSION@
Release:        0
Summary:        Osmocom's MSC for 2G and 3G circuit-switched mobile networks
License:        AGPL-3.0-or-later AND GPL-2.0-only
Group:          Productivity/Telephony/Servers
URL:            https://osmocom.org/projects/osmomsc
Source:         %{name}-%{version}.tar.xz
BuildRequires:  autoconf
BuildRequires:  automake
BuildRequires:  libtool
%if 0%{?suse_version}
BuildRequires:  systemd-rpm-macros
%endif
BuildRequires:  pkgconfig >= 0.20
BuildRequires:  pkgconfig(sqlite3)
BuildRequires:  pkgconfig(libcrypto) >= 0.9.5
BuildRequires:  pkgconfig(libosmo-gsup-client) >= 1.7.0
BuildRequires:  pkgconfig(libosmo-mgcp-client) >= 1.12.0
BuildRequires:  pkgconfig(libosmo-netif) >= 1.4.0
BuildRequires:  pkgconfig(libosmo-sccp) >= 1.8.0
BuildRequires:  pkgconfig(libosmo-sigtran) >= 1.8.0
BuildRequires:  pkgconfig(libosmoabis) >= 1.5.0
BuildRequires:  pkgconfig(libosmocore) >= 1.9.0
BuildRequires:  pkgconfig(libosmoctrl) >= 1.9.0
BuildRequires:  pkgconfig(libosmogsm) >= 1.9.0
BuildRequires:  pkgconfig(libosmovty) >= 1.9.0
BuildRequires:  pkgconfig(libsmpp34) >= 1.14.0
####
BuildRequires:  lksctp-tools-devel
####
%{?systemd_requires}
%if %{with_iu}
BuildRequires:  pkgconfig(libasn1c) >= 0.9.30
BuildRequires:  pkgconfig(libosmo-ranap) >= 1.5.0
%endif

%description
The Mobile Switching Center (MSC) is the heart of 2G/3G
circuit-switched services.  It terminates the A-interface links from the
Base Station Controllers (BSC) and handles the MM and CC sub-layers of
the Layer 3 protocol from the phones (MS).

This Osmocom implementation of the MSC handles A interfaces via 3GPP
AoIP in an ASP role.  It furthermore implements IETF MGCP against an
external media gateway, such as OsmoMGW.  It does *not* implement MAP
towards a HLR, but the much simpler Osmocom GSUP protocol, which can
be translated to MAP if needed.

%prep
%setup -q

%build
echo "%{version}" >.tarball-version
autoreconf -fi
%configure \
%if %{with_iu}
  --enable-iu \
%endif
  --enable-smpp \
  --docdir=%{_docdir}/%{name} \
  --with-systemdsystemunitdir=%{_unitdir}

make %{?_smp_mflags}

%install
%make_install

%preun
%if 0%{?suse_version}
%service_del_preun %{name}.service
%endif

%postun
%if 0%{?suse_version}
%service_del_postun %{name}.service
%endif

%pre
getent group osmocom >/dev/null || groupadd --system osmocom
getent passwd osmocom >/dev/null || useradd --system --gid osmocom --home-dir /var/lib/osmocom \
                                            --shell /sbin/nologin --comment "Open Source Mobile Communications" osmocom
%if 0%{?suse_version}
%service_add_pre %{name}.service
%endif

%post
%if 0%{?suse_version}
%service_add_post %{name}.service
%endif
chown osmocom:osmocom /etc/osmocom/osmo-msc.cfg
chmod 0660 /etc/osmocom/osmo-msc.cfg
chown root:osmocom /etc/osmocom
chmod 2775 /etc/osmocom
mkdir -p /var/lib/osmocom
chown -R osmocom:osmocom /var/lib/osmocom

%check
make %{?_smp_mflags} check || (find . -name testsuite.log -exec cat {} +)

%files
%license COPYING
%doc AUTHORS README.md
%dir %{_docdir}/%{name}/examples
%dir %{_docdir}/%{name}/examples/osmo-msc
%{_docdir}/%{name}/examples/osmo-msc/osmo-msc.cfg
%{_docdir}/%{name}/examples/osmo-msc/osmo-msc_custom-sccp.cfg
%{_docdir}/%{name}/examples/osmo-msc/osmo-msc_multi-cs7.cfg
%{_bindir}/osmo-msc
%{_unitdir}/%{name}.service
%dir %{_sysconfdir}/osmocom
%config(noreplace) %{_sysconfdir}/osmocom/osmo-msc.cfg

%changelog
