add libosmo-mslookup abstract client

mslookup is a key concept in Distributed GSM, which allows querying the current
location of a subscriber in a number of cooperating but independent core
network sites, by arbitrary service names and by MSISDN/IMSI.

Add the abstract mslookup client library. An actual lookup method (besides
mslookup_client_fake.c) is added in a subsequent patch.

For a detailed overview of this and upcoming patches, please see the elaborate
comment at the top of mslookup.c.

Add as separate library, libosmo-mslookup, to allow adding D-GSM capability to
arbitrary client programs.

osmo-hlr will be the only mslookup server implementation, added in a subsequent
patch.

osmo-hlr itself will also use this library and act as an mslookup client, when
requesting the home HLR for locally unknown IMSIs.

Related: OS#4237
Patch-by: osmith, nhofmeyr
Change-Id: I83487ab8aad1611eb02e997dafbcb8344da13df1
changes/02/16202/21
Oliver Smith 3 years ago committed by laforge
parent 81b92bbe69
commit bf7deda0fc
  1. 2
      .gitignore
  2. 3
      configure.ac
  3. 22
      debian/control
  4. 5
      debian/libosmo-mslookup-dev.install
  5. 1
      debian/libosmo-mslookup0.install
  6. 7
      include/Makefile.am
  7. 1
      include/osmocom/hlr/logging.h
  8. 121
      include/osmocom/mslookup/mslookup.h
  9. 132
      include/osmocom/mslookup/mslookup_client.h
  10. 34
      include/osmocom/mslookup/mslookup_client_fake.h
  11. 11
      libosmo-mslookup.pc.in
  12. 5
      src/Makefile.am
  13. 7
      src/logging.c
  14. 23
      src/mslookup/Makefile.am
  15. 321
      src/mslookup/mslookup.c
  16. 310
      src/mslookup/mslookup_client.c
  17. 156
      src/mslookup/mslookup_client_fake.c
  18. 1
      tests/Makefile.am
  19. 49
      tests/mslookup/Makefile.am
  20. 245
      tests/mslookup/mslookup_client_test.c
  21. 47
      tests/mslookup/mslookup_client_test.err
  22. 88
      tests/mslookup/mslookup_test.c
  23. 22
      tests/mslookup/mslookup_test.err
  24. 12
      tests/testsuite.at

2
.gitignore vendored

@ -51,6 +51,8 @@ tests/gsup/gsup_test
tests/db/db_test
tests/hlr_vty_test.db*
tests/db_upgrade/*.dump
tests/mslookup/mslookup_client_test
tests/mslookup/mslookup_test
# manuals
doc/manuals/*.html

@ -174,10 +174,12 @@ AC_OUTPUT(
doc/examples/Makefile
src/Makefile
src/gsupclient/Makefile
src/mslookup/Makefile
include/Makefile
include/osmocom/Makefile
include/osmocom/hlr/Makefile
libosmo-gsup-client.pc
libosmo-mslookup.pc
sql/Makefile
doc/manuals/Makefile
contrib/Makefile
@ -188,4 +190,5 @@ AC_OUTPUT(
tests/gsup_server/Makefile
tests/db/Makefile
tests/db_upgrade/Makefile
tests/mslookup/Makefile
)

22
debian/control vendored

@ -59,6 +59,28 @@ Description: Development headers of Osmocom GSUP client library
.
This package contains the development headers.
Package: libosmo-mslookup0
Section: libs
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends},
${misc:Depends}
Pre-Depends: ${misc:Pre-Depends}
Description: Osmocom MS lookup library
This shared library contains routines for looking up mobile subscribers.
Package: libosmo-mslookup-dev
Architecture: any
Multi-Arch: same
Depends: ${misc:Depends},
libosmo-mslookup0 (= ${binary:Version}),
libosmocore-dev
Pre-Depends: ${misc:Pre-Depends}
Description: Development headers of Osmocom MS lookup library
This shared library contains routines for looking up mobile subscribers.
.
This package contains the development headers.
Package: osmo-hlr-doc
Architecture: all
Section: doc

@ -0,0 +1,5 @@
usr/include/osmocom/mslookup
usr/lib/*/libosmo-mslookup*.a
usr/lib/*/libosmo-mslookup*.so
usr/lib/*/libosmo-mslookup*.la
usr/lib/*/pkgconfig/libosmo-mslookup.pc

@ -0,0 +1 @@
usr/lib/*/libosmo-mslookup*.so.*

@ -1,3 +1,8 @@
SUBDIRS = osmocom
nobase_include_HEADERS = osmocom/gsupclient/gsup_client.h
nobase_include_HEADERS = \
osmocom/gsupclient/gsup_client.h \
osmocom/mslookup/mslookup_client_fake.h \
osmocom/mslookup/mslookup_client.h \
osmocom/mslookup/mslookup.h \
$(NULL)

@ -8,6 +8,7 @@ enum {
DGSUP,
DAUC,
DSS,
DMSLOOKUP,
};
extern const struct log_info hlr_log_info;

@ -0,0 +1,121 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*! \defgroup mslookup Distributed GSM: finding subscribers
* @{
* \file mslookup.h
*/
#pragma once
#include <osmocom/core/utils.h>
#include <osmocom/core/sockaddr_str.h>
#include <osmocom/gsm/protocol/gsm_23_003.h>
#define OSMO_MSLOOKUP_SERVICE_MAXLEN 64
bool osmo_mslookup_service_valid(const char *service);
enum osmo_mslookup_id_type {
OSMO_MSLOOKUP_ID_NONE = 0,
OSMO_MSLOOKUP_ID_IMSI,
OSMO_MSLOOKUP_ID_MSISDN,
};
extern const struct value_string osmo_mslookup_id_type_names[];
static inline const char *osmo_mslookup_id_type_name(enum osmo_mslookup_id_type val)
{ return get_value_string(osmo_mslookup_id_type_names, val); }
struct osmo_mslookup_id {
enum osmo_mslookup_id_type type;
union {
char imsi[GSM23003_IMSI_MAX_DIGITS+1];
char msisdn[GSM23003_MSISDN_MAX_DIGITS+1];
};
};
int osmo_mslookup_id_cmp(const struct osmo_mslookup_id *a, const struct osmo_mslookup_id *b);
bool osmo_mslookup_id_valid(const struct osmo_mslookup_id *id);
enum osmo_mslookup_result_code {
OSMO_MSLOOKUP_RC_NONE = 0,
/*! An intermediate valid result. The request is still open for more results. */
OSMO_MSLOOKUP_RC_RESULT,
/*! Returned when the final request timeout has elapsed without results. */
OSMO_MSLOOKUP_RC_NOT_FOUND,
};
extern const struct value_string osmo_mslookup_result_code_names[];
static inline const char *osmo_mslookup_result_code_name(enum osmo_mslookup_result_code val)
{ return get_value_string(osmo_mslookup_result_code_names, val); }
/*! Information to request from a lookup. */
struct osmo_mslookup_query {
/*! Which service to request, by freely invented names. For service name conventions (for voice, SMS, HLR,...),
* refer to the OsmoHLR user's manual http://ftp.osmocom.org/docs/latest/osmohlr-usermanual.pdf */
char service[OSMO_MSLOOKUP_SERVICE_MAXLEN + 1];
/*! IMSI or MSISDN to look up. */
struct osmo_mslookup_id id;
/*! Caller provided private data, if desired. */
void *priv;
};
/*! Result data as passed back to a lookup client that invoked an osmo_mslookup_client_request. */
struct osmo_mslookup_result {
/*! Outcome of the request. */
enum osmo_mslookup_result_code rc;
/*! IP address and port to reach the given service via IPv4, if any. */
struct osmo_sockaddr_str host_v4;
/*! IP address and port to reach the given service via IPv6, if any. */
struct osmo_sockaddr_str host_v6;
/*! How long ago the service last verified presence of the subscriber, in seconds, or zero if the presence is
* invariable (like the home HLR record for an IMSI).
* If a subscriber has recently moved to a different location, we get multiple replies and want to choose the
* most recent one. If this were a timestamp, firstly the time zones would need to be taken care of.
* Even if we choose UTC, a service provider with an inaccurate date/time would end up affecting the result.
* The least susceptible to configuration errors or difference in local and remote clock is a value that
* indicates the actual age of the record in seconds. The time that the lookup query took to be answered should
* be neglectable here, since we would typically wait one second (or very few seconds) for lookup replies,
* while typical Location Updating periods are in the range of 15 minutes. */
uint32_t age;
/*! Whether this is the last result returned for this request. */
bool last;
};
int osmo_mslookup_query_init_from_domain_str(struct osmo_mslookup_query *q, const char *domain);
size_t osmo_mslookup_id_name_buf(char *buf, size_t buflen, const struct osmo_mslookup_id *id);
char *osmo_mslookup_id_name_c(void *ctx, const struct osmo_mslookup_id *id);
char *osmo_mslookup_id_name_b(char *buf, size_t buflen, const struct osmo_mslookup_id *id);
size_t osmo_mslookup_result_to_str_buf(char *buf, size_t buflen,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result);
char *osmo_mslookup_result_name_c(void *ctx,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result);
char *osmo_mslookup_result_name_b(char *buf, size_t buflen,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result);
/*! @} */

@ -0,0 +1,132 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <osmocom/core/linuxlist.h>
#include <osmocom/core/timer.h>
#include <osmocom/core/sockaddr_str.h>
#include <osmocom/mslookup/mslookup.h>
struct osmo_mslookup_client;
struct osmo_mslookup_result;
typedef void (*osmo_mslookup_cb_t)(struct osmo_mslookup_client *client,
uint32_t request_handle,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result);
/*! This handling information is passed along with a lookup request.
* It tells the osmo_mslookup_client layer how to handle responses received from various mslookup methods (at the time
* of writing only mDNS exists as a method, but the intention is to easily allow adding other methods in the future).
* This query handling info is not seen by the individual method implementations, to clarify that it is the
* osmo_mslookup_client layer that takes care of these details. */
struct osmo_mslookup_query_handling {
/*! Wait at least this long before returning any results.
*
* If nonzero, result_cb will be called as soon as this delay has elapsed, either with the so far youngest age
* result, or with a "not found yet" result. After this delay has elapsed, receiving results will continue
* until result_timeout_milliseconds has elapsed.
*
* If zero, responses are fed to the result_cb right from the start, every time a younger aged result than
* before comes in.
*
* If a result with age == 0 is received, min_wait_milliseconds is ignored, the result is returned immediately
* and listening for responses ends.
*
* Rationale: If a subscriber has recently moved between sites, multiple results will arrive, and the youngest
* age wins. It can make sense to wait a minimum time for responses before determining the winning result.
*
* However, if no result or no valid result has arrived within a short period, the subscriber may be at a site
* that is far away or that is currently experiencing high latency. It is thus a good safety net to still
* receive results for an extended period of time.
*
* For some services, it is possible to establish links to every received result, and whichever link succeeds
* will be used (for example for SIP calls: first to pick up the call gets connected, the others are dropped
* silently).
*/
uint32_t min_wait_milliseconds;
/*! Total time in milliseconds to listen for lookup responses.
*
* When this timeout elapses, osmo_mslookup_client_request_cancel() is called implicitly; Manually invoking
* osmo_mslookup_client_request_cancel() after result_timeout_milliseconds has elapsed is not necessary, but is
* still safe to do anyway.
*
* If zero, min_wait_milliseconds is also used as result_timeout_milliseconds; if that is also zero, a default
* timeout value is used.
*
* If result_timeout_milliseconds <= min_wait_milliseconds, then min_wait_milliseconds is used as
* result_timeout_milliseconds, i.e. the timeout triggers as soon as min_wait_milliseconds hits.
*
* osmo_mslookup_client_request_cancel() can be called any time to end the request.
*/
uint32_t result_timeout_milliseconds;
/*! Invoked every time a result with a younger age than the previous result has arrived.
* To stop receiving results before result_timeout_milliseconds has elapsed, call
* osmo_mslookup_client_request_cancel().
*/
osmo_mslookup_cb_t result_cb;
};
uint32_t osmo_mslookup_client_request(struct osmo_mslookup_client *client,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_query_handling *handling);
void osmo_mslookup_client_request_cancel(struct osmo_mslookup_client *client, uint32_t request_handle);
struct osmo_mslookup_client *osmo_mslookup_client_new(void *ctx);
bool osmo_mslookup_client_active(struct osmo_mslookup_client *client);
void osmo_mslookup_client_free(struct osmo_mslookup_client *client);
/*! Describe a specific mslookup client method implementation. This struct is only useful for a lookup method
* implementation to add itself to an osmo_mslookup_client, see for example osmo_mslookup_client_add_mdns(). */
struct osmo_mslookup_client_method {
struct llist_head entry;
/*! Human readable name of this lookup method. */
const char *name;
/*! Private data for the lookup method implementation. */
void *priv;
/*! Backpointer to the client this method is added to. */
struct osmo_mslookup_client *client;
/*! Launch a lookup query. Called from osmo_mslookup_client_request().
* The implementation returns results by calling osmo_mslookup_client_rx_result(). */
void (*request)(struct osmo_mslookup_client_method *method,
const struct osmo_mslookup_query *query,
uint32_t request_handle);
/*! End a lookup query. Called from osmo_mslookup_client_request_cancel(). It is guaranteed to be called
* exactly once per above request() invocation. (The API user is required to invoke
* osmo_mslookup_client_request_cancel() exactly once per osmo_mslookup_client_request().) */
void (*request_cleanup)(struct osmo_mslookup_client_method *method,
uint32_t request_handle);
/*! The mslookup_client is removing this method, clean up all open requests, lists and allocations. */
void (*destruct)(struct osmo_mslookup_client_method *method);
};
void osmo_mslookup_client_method_add(struct osmo_mslookup_client *client,
struct osmo_mslookup_client_method *method);
bool osmo_mslookup_client_method_del(struct osmo_mslookup_client *client,
struct osmo_mslookup_client_method *method);
void osmo_mslookup_client_rx_result(struct osmo_mslookup_client *client, uint32_t request_handle,
const struct osmo_mslookup_result *result);

@ -0,0 +1,34 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
/*! MS lookup fake API for testing purposes. */
#include <osmocom/mslookup/mslookup_client.h>
struct osmo_mslookup_fake_response {
struct timeval time_to_reply;
struct osmo_mslookup_id for_id;
const char *for_service;
struct osmo_mslookup_result result;
bool sent;
};
struct osmo_mslookup_client_method *osmo_mslookup_client_add_fake(struct osmo_mslookup_client *client,
struct osmo_mslookup_fake_response *responses,
size_t responses_len);

@ -0,0 +1,11 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: Osmocom MS Lookup Library
Description: C Utility Library
Version: @VERSION@
Libs: -L${libdir} @TALLOC_LIBS@ -losmogsm -losmo-mslookup -losmocore
Cflags: -I${includedir}/

@ -1,4 +1,7 @@
SUBDIRS = gsupclient
SUBDIRS = \
gsupclient \
mslookup \
$(NULL)
AM_CFLAGS = \
-Wall \

@ -25,7 +25,12 @@ const struct log_info_cat hlr_log_info_cat[] = {
.color = "\033[1;34m",
.enabled = 1, .loglevel = LOGL_NOTICE,
},
[DMSLOOKUP] = {
.name = "DMSLOOKUP",
.description = "Mobile Subscriber Lookup",
.color = "\033[1;35m",
.enabled = 1, .loglevel = LOGL_NOTICE,
},
};
const struct log_info hlr_log_info = {

@ -0,0 +1,23 @@
# This is _NOT_ the library release version, it's an API version.
# Please read chapter "Library interface versions" of the libtool documentation
# before making any modifications: https://www.gnu.org/software/libtool/manual/html_node/Versioning.html
LIBVERSION=0:0:0
AM_CPPFLAGS = $(all_includes) -I$(top_srcdir)/include -I$(top_builddir)/include
AM_CFLAGS = -fPIC -Wall $(PCSC_CFLAGS) $(TALLOC_CFLAGS) $(LIBOSMOCORE_CFLAGS)
AM_LDFLAGS = $(COVERAGE_LDFLAGS)
lib_LTLIBRARIES = libosmo-mslookup.la
libosmo_mslookup_la_SOURCES = \
mslookup.c \
mslookup_client.c \
mslookup_client_fake.c \
$(NULL)
libosmo_mslookup_la_LDFLAGS = -version-info $(LIBVERSION)
libosmo_mslookup_la_LIBADD = \
$(LIBOSMOCORE_LIBS) \
$(LIBOSMOGSM_LIBS) \
$(TALLOC_LIBS) \
$(NULL)

@ -0,0 +1,321 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include <errno.h>
#include <osmocom/gsm/gsm23003.h>
#include <osmocom/mslookup/mslookup.h>
/*! \addtogroup mslookup
*
* Distributed GSM: finding subscribers
*
* There are various aspects of the D-GSM code base in osmo-hlr.git, here is an overview:
*
* mslookup is the main enabler of D-GSM, a concept for connecting services between independent core network stacks.
*
* D-GSM consists of:
* (1) mslookup client to find subscribers:
* (a) external clients like ESME, SIP PBX, ... ask osmo-hlr to tell where to send SMS, voice calls, ...
* (b) osmo-hlr's own mslookup client asks remote osmo-hlrs whether they know a given IMSI.
* (2) when a subscriber was found at a remote HLR, GSUP gets forwarded there:
* (a) to deliver messages for the GSUP proxy, osmo-hlr manages many GSUP clients to establish links to remote HLRs.
* (b) osmo-hlr has a GSUP proxy layer that caches data of IMSIs that get proxied to a remote HLR.
* (c) decision making to distinguish local IMSIs from ones proxied to a remote HLR.
*
* (1) mslookup is a method of finding subscribers using (multicast) queries, by MSISDN or by IMSI.
* It is open to various lookup methods, the first one being multicast DNS.
* An mslookup client sends a request, and an mslookup server responds.
* The mslookup server is implemented by osmo-hlr. mslookup clients are arbitrary programs, like an ESME or a SIP PBX.
* Hence the mslookup client is public API, while the mslookup server is implemented "privately" in osmo-hlr.
*
* (1a) Public mslookup client: libosmo-mslookup
* src/mslookup/mslookup.c Things useful for both client and server.
* src/mslookup/mslookup_client.c The client API, which can use various lookup methods,
* and consolidates results from various responders.
* src/mslookup/mslookup_client_mdns.c lookup method implementing multicast DNS, client side.
*
* src/mslookup/osmo-mslookup-client.c Utility program to ease invocation for (blocking) mslookup clients.
*
* src/mslookup/mslookup_client_fake.c lookup method generating fake results, for testing client implementations.
*
* src/mslookup/mdns*.c implementation of DNS to be used by mslookup_client_mdns.c,
* and the mslookup_server.c.
*
* contrib/dgsm/esme_dgsm.py Example implementation for an mslookup enabled SMS handler.
* contrib/dgsm/freeswitch_dialplan_dgsm.py Example implementation for an mslookup enabled FreeSWITCH dialplan.
* contrib/dgsm/osmo-mslookup-pipe.py Example for writing a python client using the osmo-mslookup-client
* cmdline.
* contrib/dgsm/osmo-mslookup-socket.py Example for writing a python client using the osmo-mslookup-client
* unix domain socket.
*
* (1b) "Private" mslookup server in osmo-hlr:
* src/mslookup_server.c Respond to mslookup queries, independent from the particular lookup method.
* src/mslookup_server_mdns.c mDNS specific implementation for mslookup_server.c.
* src/dgsm_vty.c Configure services that mslookup server sends to remote requests.
*
* (2) Proxy and GSUP clients to remote HLR instances:
*
* (a) Be a GSUP client to forward to a remote HLR:
* src/gsupclient/ The same API that is used by osmo-{msc,sgsn} is also used to forward GSUP to remote osmo-hlrs.
* src/remote_hlr.c Establish links to remote osmo-hlrs, where this osmo-hlr is a client (proxying e.g. for an MSC).
*
* (b) Keep track of remotely handled IMSIs:
* src/proxy.c Keep track of proxied IMSIs and cache important subscriber data.
*
* (c) Direct GSUP request to the right destination: either the local or a remote HLR:
* src/dgsm.c The glue that makes osmo-hlr distinguish between local IMSIs and those that are proxied to another
* osmo-hlr.
* src/dgsm_vty.c Config.
*
* @{
* \file mslookup.c
*/
const struct value_string osmo_mslookup_id_type_names[] = {
{ OSMO_MSLOOKUP_ID_NONE, "none" },
{ OSMO_MSLOOKUP_ID_IMSI, "imsi" },
{ OSMO_MSLOOKUP_ID_MSISDN, "msisdn" },
{}
};
const struct value_string osmo_mslookup_result_code_names[] = {
{ OSMO_MSLOOKUP_RC_NONE, "none" },
{ OSMO_MSLOOKUP_RC_RESULT, "result" },
{ OSMO_MSLOOKUP_RC_NOT_FOUND, "not-found" },
{}
};
/*! Compare two struct osmo_mslookup_id.
* \returns 0 if a and b are equal,
* < 0 if a (or the ID type / start of ID) is < b,
* > 0 if a (or the ID type / start of ID) is > b.
*/
int osmo_mslookup_id_cmp(const struct osmo_mslookup_id *a, const struct osmo_mslookup_id *b)
{
int cmp;
if (a == b)
return 0;
if (!a)
return -1;
if (!b)
return 1;
cmp = OSMO_CMP(a->type, b->type);
if (cmp)
return cmp;
switch (a->type) {
case OSMO_MSLOOKUP_ID_IMSI:
return strncmp(a->imsi, b->imsi, sizeof(a->imsi));
case OSMO_MSLOOKUP_ID_MSISDN:
return strncmp(a->msisdn, b->msisdn, sizeof(a->msisdn));
default:
return 0;
}
}
bool osmo_mslookup_id_valid(const struct osmo_mslookup_id *id)
{
switch (id->type) {
case OSMO_MSLOOKUP_ID_IMSI:
return osmo_imsi_str_valid(id->imsi);
case OSMO_MSLOOKUP_ID_MSISDN:
return osmo_msisdn_str_valid(id->msisdn);
default:
return false;
}
}
bool osmo_mslookup_service_valid(const char *service)
{
return strlen(service) > 0;
}
/*! Write ID and ID type to a buffer.
* \param[out] buf nul-terminated {id}.{id_type} string (e.g. "1234.msisdn") or
* "?.none" if the ID type is invalid.
* \returns amount of bytes written to buf.
*/
size_t osmo_mslookup_id_name_buf(char *buf, size_t buflen, const struct osmo_mslookup_id *id)
{
struct osmo_strbuf sb = { .buf = buf, .len = buflen };
switch (id->type) {
case OSMO_MSLOOKUP_ID_IMSI:
OSMO_STRBUF_PRINTF(sb, "%s", id->imsi);
break;
case OSMO_MSLOOKUP_ID_MSISDN:
OSMO_STRBUF_PRINTF(sb, "%s", id->msisdn);
break;
default:
OSMO_STRBUF_PRINTF(sb, "?");
break;
}
OSMO_STRBUF_PRINTF(sb, ".%s", osmo_mslookup_id_type_name(id->type));
return sb.chars_needed;
}
/*! Same as osmo_mslookup_id_name_buf(), but return a talloc allocated string of sufficient size. */
char *osmo_mslookup_id_name_c(void *ctx, const struct osmo_mslookup_id *id)
{
OSMO_NAME_C_IMPL(ctx, 64, "ERROR", osmo_mslookup_id_name_buf, id)
}
/*! Same as osmo_mslookup_id_name_buf(), but directly return the char* (for printf-like string formats). */
char *osmo_mslookup_id_name_b(char *buf, size_t buflen, const struct osmo_mslookup_id *id)
{
int rc = osmo_mslookup_id_name_buf(buf, buflen, id);
if (rc < 0 && buflen)
buf[0] = '\0';
return buf;
}
/*! Write mslookup result string to buffer.
* \param[in] query with the service, ID and ID type to be written to buf like a domain string, or NULL to omit.
* \param[in] result with the result code, IPv4/v6 and age to be written to buf or NULL to omit.
* \param[out] buf result as flat string, which looks like the following for a valid query and result with IPv4 and v6
* answer: "sip.voice.1234.msisdn -> ipv4: 42.42.42.42:1337 -> ipv6: [1234:5678:9ABC::]:1338 (age=1)",
* the result part can also be " -> timeout" or " -> rc=5" depending on the result code.
* \returns amount of bytes written to buf.
*/
size_t osmo_mslookup_result_to_str_buf(char *buf, size_t buflen,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result)
{
struct osmo_strbuf sb = { .buf = buf, .len = buflen };
if (query) {
OSMO_STRBUF_PRINTF(sb, "%s.", query->service);
OSMO_STRBUF_APPEND(sb, osmo_mslookup_id_name_buf, &query->id);
}
if (result && result->rc == OSMO_MSLOOKUP_RC_NONE)
result = NULL;
if (result) {
if (result->rc != OSMO_MSLOOKUP_RC_RESULT) {
OSMO_STRBUF_PRINTF(sb, " %s", osmo_mslookup_result_code_name(result->rc));
} else {
if (result->host_v4.ip[0]) {
OSMO_STRBUF_PRINTF(sb, " -> ipv4: " OSMO_SOCKADDR_STR_FMT,
OSMO_SOCKADDR_STR_FMT_ARGS(&result->host_v4));
}
if (result->host_v6.ip[0]) {
OSMO_STRBUF_PRINTF(sb, " -> ipv6: " OSMO_SOCKADDR_STR_FMT,
OSMO_SOCKADDR_STR_FMT_ARGS(&result->host_v6));
}
OSMO_STRBUF_PRINTF(sb, " (age=%u)", result->age);
}
OSMO_STRBUF_PRINTF(sb, " %s", result->last ? "(last)" : "(not-last)");
}
return sb.chars_needed;
}
/*! Same as osmo_mslookup_result_to_str_buf(), but return a talloc allocated string of sufficient size. */
char *osmo_mslookup_result_name_c(void *ctx,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result)
{
OSMO_NAME_C_IMPL(ctx, 64, "ERROR", osmo_mslookup_result_to_str_buf, query, result)
}
/*! Same as osmo_mslookup_result_to_str_buf(), but directly return the char* (for printf-like string formats). */
char *osmo_mslookup_result_name_b(char *buf, size_t buflen,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_result *result)
{
int rc = osmo_mslookup_result_to_str_buf(buf, buflen, query, result);
if (rc < 0 && buflen)
buf[0] = '\0';
return buf;
}
/*! Copy part of a string to a buffer and nul-terminate it.
* \returns 0 on success, negative on error.
*/
static int token(char *dest, size_t dest_size, const char *start, const char *end)
{
int len;
if (start >= end)
return -10;
len = end - start;
if (len >= dest_size)
return -11;
strncpy(dest, start, len);
dest[len] = '\0';
return 0;
}
/*! Parse a string like "foo.moo.goo.123456789012345.msisdn" into service="foo.moo.goo", id="123456789012345" and
* id_type="msisdn", placed in a struct osmo_mslookup_query.
* \param q Write parsed query to this osmo_mslookup_query.
* \param domain Human readable domain string like "sip.voice.12345678.msisdn".
* \returns 0 on success, negative on error.
*/
int osmo_mslookup_query_init_from_domain_str(struct osmo_mslookup_query *q, const char *domain)
{
const char *last_dot;
const char *second_last_dot;
const char *id_type;
const char *id;
int rc;
*q = (struct osmo_mslookup_query){};
if (!domain)
return -1;
last_dot = strrchr(domain, '.');
if (!last_dot)
return -2;
if (last_dot <= domain)
return -3;
for (second_last_dot = last_dot - 1; second_last_dot > domain && *second_last_dot != '.'; second_last_dot--);
if (second_last_dot == domain || *second_last_dot != '.')
return -3;
id_type = last_dot + 1;
if (!*id_type)
return -4;
q->id.type = get_string_value(osmo_mslookup_id_type_names, id_type);
id = second_last_dot + 1;
switch (q->id.type) {
case OSMO_MSLOOKUP_ID_IMSI:
rc = token(q->id.imsi, sizeof(q->id.imsi), id, last_dot);
if (rc)
return rc;
if (!osmo_imsi_str_valid(q->id.imsi))
return -5;
break;
case OSMO_MSLOOKUP_ID_MSISDN:
rc = token(q->id.msisdn, sizeof(q->id.msisdn), id, last_dot);
if (rc)
return rc;
if (!osmo_msisdn_str_valid(q->id.msisdn))
return -6;
break;
default:
return -7;
}
return token(q->service, sizeof(q->service), domain, second_last_dot);
}
/*! @} */

@ -0,0 +1,310 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <osmocom/hlr/logging.h>
#include <osmocom/mslookup/mslookup_client.h>
/*! Lookup client's internal data for a query. */
struct osmo_mslookup_client {
struct llist_head lookup_methods;
struct llist_head requests;
uint32_t next_request_handle;
};
/*! Lookup client's internal data for a query.
* The request methods only get to see the query part, and result handling is done commonly for all request methods. */
struct osmo_mslookup_client_request {
struct llist_head entry;
struct osmo_mslookup_client *client;
uint32_t request_handle;
struct osmo_mslookup_query query;
struct osmo_mslookup_query_handling handling;
struct osmo_timer_list timeout;
bool waiting_min_delay;
struct osmo_mslookup_result result;
};
static struct osmo_mslookup_client_request *get_request(struct osmo_mslookup_client *client, uint32_t request_handle)
{
struct osmo_mslookup_client_request *r;
if (!request_handle)
return NULL;
llist_for_each_entry(r, &client->requests, entry) {
if (r->request_handle == request_handle)
return r;
}
return NULL;
}
struct osmo_mslookup_client *osmo_mslookup_client_new(void *ctx)
{
struct osmo_mslookup_client *client = talloc_zero(ctx, struct osmo_mslookup_client);
OSMO_ASSERT(client);
INIT_LLIST_HEAD(&client->lookup_methods);
INIT_LLIST_HEAD(&client->requests);
return client;
}
/*! Return whether any lookup methods are available.
* \param[in] client Client to query.
* \return true when a client is present that has at least one osmo_mslookup_client_method registered.
*/
bool osmo_mslookup_client_active(struct osmo_mslookup_client *client)
{
if (!client)
return false;
if (llist_empty(&client->lookup_methods))
return false;
return true;
}
static void _osmo_mslookup_client_method_del(struct osmo_mslookup_client_method *method)
{
if (method->destruct)
method->destruct(method);
llist_del(&method->entry);
talloc_free(method);
}
/*! Stop and free mslookup client and all registered lookup methods.
*/
void osmo_mslookup_client_free(struct osmo_mslookup_client *client)
{
struct osmo_mslookup_client_method *m, *n;
if (!client)
return;
llist_for_each_entry_safe(m, n, &client->lookup_methods, entry) {
_osmo_mslookup_client_method_del(m);
}
talloc_free(client);
}
/*! Add an osmo_mslookup_client_method to service MS Lookup requests.
* Note, osmo_mslookup_client_method_del() will talloc_free() the method pointer, so it needs to be dynamically
* allocated.
* \param client The osmo_mslookup_client instance to add to.
* \param method A fully initialized method struct, allocated by talloc.
*/
void osmo_mslookup_client_method_add(struct osmo_mslookup_client *client,
struct osmo_mslookup_client_method *method)
{
method->client = client;
llist_add_tail(&method->entry, &client->lookup_methods);
}
/*! \return false if the method was not listed, true if the method was listed, removed and talloc_free()d.
*/
bool osmo_mslookup_client_method_del(struct osmo_mslookup_client *client,
struct osmo_mslookup_client_method *method)
{
struct osmo_mslookup_client_method *m;
llist_for_each_entry(m, &client->lookup_methods, entry) {
if (m == method) {
_osmo_mslookup_client_method_del(method);
return true;
}
}
return false;
}
static void osmo_mslookup_request_send_result(struct osmo_mslookup_client_request *r, bool finish)
{
struct osmo_mslookup_client *client = r->client;
uint32_t request_handle = r->request_handle;
r->result.last = finish;
r->handling.result_cb(r->client, r->request_handle, &r->query, &r->result);
/* Make sure the request struct is discarded.
* The result_cb() may already have triggered a cleanup, so query by request_handle. */
if (finish)
osmo_mslookup_client_request_cancel(client, request_handle);
}
void osmo_mslookup_client_rx_result(struct osmo_mslookup_client *client, uint32_t request_handle,
const struct osmo_mslookup_result *result)
{
struct osmo_mslookup_client_request *req = get_request(client, request_handle);
if (!req) {
LOGP(DMSLOOKUP, LOGL_ERROR,
"Internal error: Got mslookup result for a request that does not exist (handle %u)\n",
req->request_handle);
return;
}
/* Ignore incoming results that are not successful */
if (result->rc != OSMO_MSLOOKUP_RC_RESULT)
return;
/* If we already stored an earlier successful result, keep that if its age is younger. */
if (req->result.rc == OSMO_MSLOOKUP_RC_RESULT
&& result->age >= req->result.age)
return;
req->result = *result;
/* If age == 0, it doesn't get any better, so return the result immediately. */
if (req->result.age == 0) {
osmo_mslookup_request_send_result(req, true);
return;
}
if (req->waiting_min_delay)
return;
osmo_mslookup_request_send_result(req, false);
}
static void _osmo_mslookup_client_request_cleanup(struct osmo_mslookup_client_request *r)
{
struct osmo_mslookup_client_method *m;
osmo_timer_del(&r->timeout);
llist_for_each_entry(m, &r->client->lookup_methods, entry) {
if (!m->request_cleanup)
continue;
m->request_cleanup(m, r->request_handle);
}
llist_del(&r->entry);
talloc_free(r);
}
static void timeout_cb(void *data);
static void set_timer(struct osmo_mslookup_client_request *r, unsigned long milliseconds)
{
osmo_timer_setup(&r->timeout, timeout_cb, r);
osmo_timer_schedule(&r->timeout, milliseconds / 1000, (milliseconds % 1000) * 1000);
}
static void timeout_cb(void *data)
{
struct osmo_mslookup_client_request *r = data;
if (r->waiting_min_delay) {
/* The initial delay has passed. See if it stops here, or whether the overall timeout continues. */
r->waiting_min_delay = false;
if (r->handling.result_timeout_milliseconds <= r->handling.min_wait_milliseconds) {
/* It ends here. Return a final result. */
if (r->result.rc != OSMO_MSLOOKUP_RC_RESULT)
r->result.rc = OSMO_MSLOOKUP_RC_NOT_FOUND;
osmo_mslookup_request_send_result(r, true);
return;
}
/* We continue to listen for results. If one is already on record, send it now. */
if (r->result.rc == OSMO_MSLOOKUP_RC_RESULT)
osmo_mslookup_request_send_result(r, false);
set_timer(r, r->handling.result_timeout_milliseconds - r->handling.min_wait_milliseconds);
return;
}
/* The final timeout has passed, finish and clean up the request. */
switch (r->result.rc) {
case OSMO_MSLOOKUP_RC_RESULT:
/* If the rc == OSMO_MSLOOKUP_RC_RESULT, this result has already been sent.
* Don't send it again, instead send an RC_NONE, last=true result. */
r->result.rc = OSMO_MSLOOKUP_RC_NONE;
break;
default:
r->result.rc = OSMO_MSLOOKUP_RC_NOT_FOUND;
break;
}
osmo_mslookup_request_send_result(r, true);
}
/*! Launch a subscriber lookup with the provided query.
* A request is cleared implicitly when the handling->result_cb is invoked; if the quer->priv pointer becomes invalid
* before that, a request should be canceled by calling osmo_mslookup_client_request_cancel() with the returned
* request_handle. A request handle of zero indicates error.
* \return a nonzero request_handle that allows ending the request, or 0 on invalid query data. */
uint32_t osmo_mslookup_client_request(struct osmo_mslookup_client *client,
const struct osmo_mslookup_query *query,
const struct osmo_mslookup_query_handling *handling)
{
struct osmo_mslookup_client_request *r;
struct osmo_mslookup_client_request *other;
struct osmo_mslookup_client_method *m;
if (!osmo_mslookup_service_valid(query->service)
|| !osmo_mslookup_id_valid(&query->id)) {
char buf[256];
LOGP(DMSLOOKUP, LOGL_ERROR, "Invalid query: %s\n",
osmo_mslookup_result_name_b(buf, sizeof(buf), query, NULL));
return 0;
}
r = talloc_zero(client, struct osmo_mslookup_client_request);
OSMO_ASSERT(r);
/* A request_handle of zero means error, so make sure we don't use a zero handle. */
if (!client->next_request_handle)
client->next_request_handle++;
*r = (struct osmo_mslookup_client_request){
.client = client,
.query = *query,
.handling = *handling,
.request_handle = client->next_request_handle++,
};
if (!r->handling.result_timeout_milliseconds)
r->handling.result_timeout_milliseconds = r->handling.min_wait_milliseconds;
if (!r->handling.result_timeout_milliseconds)
r->handling.result_timeout_milliseconds = 1000;
/* Paranoia: make sure a request_handle exists only once, by expiring an already existing one. This is unlikely
* to happen in practice: before we get near wrapping a uint32_t range, previous requests should long have
* timed out or ended. */
llist_for_each_entry(other, &client->requests, entry) {
if (other->request_handle != r->request_handle)
continue;
osmo_mslookup_request_send_result(other, true);
/* we're sure it exists only once. */
break;
}
/* Now sure that the new request_handle does not exist a second time. */
llist_add_tail(&r->entry, &client->requests);
if (r->handling.min_wait_milliseconds) {
r->waiting_min_delay = true;
set_timer(r, r->handling.min_wait_milliseconds);
} else {
set_timer(r, r->handling.result_timeout_milliseconds);
}
/* Let the lookup implementations know */
llist_for_each_entry(m, &client->lookup_methods, entry) {
m->request(m, query, r->request_handle);
}
return r->request_handle;
}
/*! End or cancel a subscriber lookup. This *must* be invoked exactly once per osmo_mslookup_client_request() invocation,
* either after a lookup has concluded or to abort an ongoing lookup.
* \param[in] request_handle The request_handle returned by an osmo_mslookup_client_request() invocation.
*/
void osmo_mslookup_client_request_cancel(struct osmo_mslookup_client *client, uint32_t request_handle)
{
struct osmo_mslookup_client_request *r = get_request(client, request_handle);
if (!r)
return;
_osmo_mslookup_client_request_cleanup(r);
}

@ -0,0 +1,156 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <osmocom/hlr/logging.h>
#include <osmocom/mslookup/mslookup_client.h>
#include <osmocom/mslookup/mslookup_client_fake.h>
#include <string.h>
/* Fake mslookup method */
struct fake_lookup_state {
struct osmo_mslookup_client *client;
struct llist_head requests;
struct osmo_timer_list async_response_timer;
struct osmo_mslookup_fake_response *responses;
size_t responses_len;
};
struct fake_lookup_request {
struct llist_head entry;
uint32_t request_handle;
struct osmo_mslookup_query query;
struct timeval received_at;
};
/*! Args for osmo_timer_schedule: seconds and microseconds. */
#define ASYNC_RESPONSE_PERIOD 0, (1e6 / 10)
static void fake_lookup_async_response(void *state);
static void fake_lookup_request(struct osmo_mslookup_client_method *method,
const struct osmo_mslookup_query *query,
uint32_t request_handle)
{
struct fake_lookup_state *state = method->priv;
char buf[256];
LOGP(DMSLOOKUP, LOGL_DEBUG, "%s(%s)\n", __func__, osmo_mslookup_result_name_b(buf, sizeof(buf), query, NULL));
/* A real implementation would send packets to some remote server.
* Here this is simulated: add to the list of requests, which fake_lookup_async_response() will reply upon
* according to the test data listing the replies that the test wants to generate. */
struct fake_lookup_request *r = talloc_zero(method->client, struct fake_lookup_request);
*r = (struct fake_lookup_request){
.request_handle = request_handle,
.query = *query,
};
osmo_gettimeofday(&r->received_at, NULL);
llist_add_tail(&r->entry, &state->requests);
}
static void fake_lookup_request_cleanup(struct osmo_mslookup_client_method *method,
uint32_t request_handle)
{
struct fake_lookup_state *state = method->priv;
/* Tear down any state associated with this handle. */
struct fake_lookup_request *r;
llist_for_each_entry(r, &state->requests, entry) {
if (r->request_handle != request_handle)
continue;
llist_del(&r->entry);
talloc_free(r);
LOGP(DMSLOOKUP, LOGL_DEBUG, "%s() ok\n", __func__);
return;
}
LOGP(DMSLOOKUP, LOGL_DEBUG, "%s() FAILED\n", __func__);
}
static void fake_lookup_async_response(void *data)
{
struct fake_lookup_state *state = data;
struct fake_lookup_request *req, *n;
struct timeval now;
char str[256];
osmo_gettimeofday(&now, NULL);
llist_for_each_entry_safe(req, n, &state->requests, entry) {
struct osmo_mslookup_fake_response *resp;
for (resp = state->responses;
(resp - state->responses) < state->responses_len;
resp++) {
struct timeval diff;
if (resp->sent)
continue;
if (osmo_mslookup_id_cmp(&req->query.id, &resp->for_id) != 0)
continue;
if (strcmp(req->query.service, resp->for_service) != 0)
continue;
timersub(&now, &req->received_at, &diff);
if (timercmp(&diff, &resp->time_to_reply, <))
continue;
/* It's time to reply to this request. */
LOGP(DMSLOOKUP, LOGL_DEBUG, "osmo_mslookup_client_rx_result(): %s\n",
osmo_mslookup_result_name_b(str, sizeof(str), &req->query, &resp->result));
osmo_mslookup_client_rx_result(state->client, req->request_handle, &resp->result);
resp->sent = true;
/* The req will have been cleaned up now, so we must not iterate over state->responses anymore
* with this req. */
break;
}
}
osmo_timer_schedule(&state->async_response_timer, ASYNC_RESPONSE_PERIOD);
}
struct osmo_mslookup_client_method *osmo_mslookup_client_add_fake(struct osmo_mslookup_client *client,
struct osmo_mslookup_fake_response *responses,
size_t responses_len)
{
struct osmo_mslookup_client_method *method = talloc_zero(client, struct osmo_mslookup_client_method);
OSMO_ASSERT(method);
struct fake_lookup_state *state = talloc_zero(method, struct fake_lookup_state);
OSMO_ASSERT(state);
*state = (struct fake_lookup_state){
.client = client,
.responses = responses,
.responses_len = responses_len,
};
INIT_LLIST_HEAD(&state->requests);
*method = (struct osmo_mslookup_client_method){
.name = "fake",
.priv = state,
.request = fake_lookup_request,
.request_cleanup = fake_lookup_request_cleanup,
};
osmo_timer_setup(&state->async_response_timer, fake_lookup_async_response, state);
osmo_mslookup_client_method_add(client, method);
osmo_timer_schedule(&state->async_response_timer, ASYNC_RESPONSE_PERIOD);
return method;
}

@ -3,6 +3,7 @@ SUBDIRS = \
gsup_server \
db \
db_upgrade \
mslookup \
$(NULL)
# The `:;' works around a Bash 3.2 bug when the output is not writeable.

@ -0,0 +1,49 @@
AM_CPPFLAGS = \
$(all_includes) \
$(NULL)
AM_CFLAGS = \
-Wall \
-ggdb3 \
-I$(top_srcdir)/include \
$(LIBOSMOCORE_CFLAGS) \
$(LIBOSMOGSM_CFLAGS) \
$(LIBOSMOABIS_CFLAGS) \
$(NULL)
AM_LDFLAGS = \
-no-install \
$(NULL)
EXTRA_DIST = \
mslookup_client_test.err \
mslookup_test.err \
$(NULL)
check_PROGRAMS = \
mslookup_client_test \
mslookup_test \
$(NULL)
mslookup_test_SOURCES = \
mslookup_test.c \
$(NULL)
mslookup_test_LDADD = \
$(top_builddir)/src/mslookup/libosmo-mslookup.la \
$(LIBOSMOGSM_LIBS) \
$(NULL)
mslookup_client_test_SOURCES = \
mslookup_client_test.c \
$(NULL)
mslookup_client_test_LDADD = \
$(top_builddir)/src/mslookup/libosmo-mslookup.la \
$(LIBOSMOGSM_LIBS) \
$(NULL)
.PHONY: update_exp
update_exp:
for i in $(check_PROGRAMS); do \
echo "Updating $$i.err"; \
$(builddir)/$$i 2>"$(srcdir)/$$i.err"; \
done

@ -0,0 +1,245 @@
/* Copyright 2019 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
*
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include <sys/time.h>
#include <string.h>
#include <osmocom/core/application.h>
#include <osmocom/core/select.h>
#include <osmocom/hlr/logging.h>
#include <osmocom/mslookup/mslookup_client_fake.h>
#include <osmocom/mslookup/mslookup_client.h>
#define SERVICE_HLR_GSUP "gsup.hlr"
#define SERVICE_SIP "sip.voice"
void *ctx = NULL;
static struct osmo_mslookup_fake_response fake_lookup_responses[] = {
{
.time_to_reply = { .tv_sec = 1, },
.for_id = {
.type = OSMO_MSLOOKUP_ID_IMSI,
.imsi = "1234567",
},
.for_service = SERVICE_HLR_GSUP,
.result = {