cellular-infrastructure
/
osmo-cbc
mirror of https://gerrit.osmocom.org/osmo-cbc
9
0
Fork 0
Code Issues Releases Wiki Activity
osmo-cbc/src/rest_api.c

736 lines
20 KiB
C
Raw Blame History

/* Osmocom CBC (Cell Broacast Centre) */
/* (C) 2019-2021 by Harald Welte <laforge@gnumonks.org>
* All Rights Reserved
*
* SPDX-License-Identifier: AGPL-3.0+
*
* 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 <string.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <jansson.h>
#include <ulfius.h>
#include <orcania.h>
#include <osmocom/core/utils.h>
#include <osmocom/core/linuxlist.h>
#include <osmocom/core/sockaddr_str.h>
#include <osmocom/gsm/protocol/gsm_48_049.h>
#define PREFIX "/api/ecbe/v1"
#include <osmocom/cbc/debug.h>
#include <osmocom/cbc/charset.h>
#include <osmocom/cbc/cbc_data.h>
#include <osmocom/cbc/rest_it_op.h>
/* get an integer value for field "key" in object "parent" */
static int json_get_integer(int *out, json_t *parent, const char *key)
{
json_t *jtmp;
if (!parent || !json_is_object(parent))
return -ENODEV;
jtmp = json_object_get(parent, key);
if (!jtmp)
return -ENOENT;
if (!json_is_integer(jtmp))
return -EINVAL;
*out = json_integer_value(jtmp);
return 0;
}
static int json_get_integer_range(int *out, json_t *parent, const char *key, int min, int max)
{
int rc, tmp;
rc = json_get_integer(&tmp, parent, key);
if (rc < 0)
return rc;
if (tmp < min || tmp > max)
return -ERANGE;
*out = tmp;
return 0;
}
/* get a string value for field "key" in object "parent" */
static const char *json_get_string(json_t *parent, const char *key)
{
json_t *jtmp;
if (!parent || !json_is_object(parent))
return NULL;
jtmp = json_object_get(parent, key);
if (!jtmp)
return NULL;
if (!json_is_string(jtmp))
return NULL;
return json_string_value(jtmp);
}
/* geographic scope (part of message_id) as per 3GPP TS 23.041 Section 9.4.1.2 "GS Code" */
static const struct value_string geo_scope_vals[] = {
{ 0, "cell_wide_immediate" },
{ 1, "plmn_wide" },
{ 2, "lac_sac_tac_wide" },
{ 3, "cell_wide" },
{ 0, NULL }
};
/* mapping of CBS DCS values for languages in 7bit GSM alphabet to ISO639-1 language codes,
* as per 3GPP TS 23.038 Section 5 */
static const struct value_string iso639_1_cbs_dcs_vals[] = {
{ 0x00, "de" },
{ 0x01, "en" },
{ 0x02, "it" },
{ 0x03, "fr" },
{ 0x04, "es" },
{ 0x05, "nl" },
{ 0x06, "sv" },
{ 0x07, "da" },
{ 0x08, "pt" },
{ 0x09, "fi" },
{ 0x0a, "no" },
{ 0x0b, "el" },
{ 0x0c, "tr" },
{ 0x0d, "hu" },
{ 0x0e, "pl" },
{ 0x20, "cs" },
{ 0x21, "he" },
{ 0x22, "ar" },
{ 0x23, "ru" },
{ 0x24, "is" },
{ 0, NULL }
};
/* values not expressed in the table above must use "language indication" at the start of the message */
/* 3GPP TS 23.041 Section 9.3.24 */
static const struct value_string ts23041_warning_type_vals[] = {
{ 0, "earthquake" },
{ 1, "tsunami" },
{ 2, "earthquake_and_tsuname" },
{ 3, "test" },
{ 4, "other" },
{ 0, NULL }
};
/* parse a smscb.schema.json/warning_type (either encoded or decoded) */
static int parse_warning_type(json_t *in, const char **errstr)
{
json_t *jtmp;
int i, rc, val;
if (!in || !json_is_object(in)) {
*errstr = "'warning_type' must be object";
return -EINVAL;
}
rc = json_get_integer_range(&i, in, "warning_type_encoded", 0, 255);
if (rc == 0) {
val = i;
} else if (rc == -ENOENT && (jtmp = json_object_get(in, "warning_type_decoded"))) {
const char *tstr = json_string_value(jtmp);
if (!tstr) {
*errstr = "'warning_type_decoded' is not a string";
return -EINVAL;
}
i = get_string_value(ts23041_warning_type_vals, tstr);
if (i < 0) {
*errstr = "'warning_type_decoded' is invalid";
return -EINVAL;
}
val = i;
} else {
*errstr = "either 'warning_type_encoded' or 'warning_type_decoded' must be present";
return -EINVAL;
}
return val;
}
/* parse a smscb.schema.json/serial_nr type (either encoded or decoded) */
static int json2serial_nr(uint16_t *out, json_t *jser_nr, const char **errstr)
{
json_t *jtmp;
int tmp, rc;
if (!jser_nr || !json_is_object(jser_nr)) {
*errstr = "'serial_nr' must be present and an object";
return -EINVAL;
}
rc = json_get_integer_range(&tmp, jser_nr, "serial_nr_encoded", 0, UINT16_MAX);
if (rc == 0) {
*out = tmp;
} else if (rc == -ENOENT && (jtmp = json_object_get(jser_nr, "serial_nr_decoded"))) {
const char *geo_scope_str;
int msg_code, upd_nr, geo_scope;
geo_scope_str = json_get_string(jtmp, "geo_scope");
if (!geo_scope_str) {
*errstr = "'geo_scope' is mandatory";
return -EINVAL;
}
geo_scope = get_string_value(geo_scope_vals, geo_scope_str);
if (geo_scope < 0) {
*errstr = "'geo_scope' is invalid";
return -EINVAL;
}
rc = json_get_integer_range(&msg_code, jtmp, "msg_code", 0, 1024);
if (rc < 0) {
*errstr = "'msg_code' is out of range";
return rc;
}
rc = json_get_integer_range(&upd_nr, jtmp, "update_nr", 0, 15);
if (rc < 0) {
*errstr = "'update_nr' is out of range";
return rc;
}
*out = ((geo_scope & 3) << 14) | ((msg_code & 0x3ff) << 4) | (upd_nr & 0xf);
return 0;
} else {
*errstr = "Either 'serial_nr_encoded' or 'serial_nr_decoded' are mandatory";
return -EINVAL;
}
return 0;
}
/* compute the number of pages needed for number of octets */
static unsigned int pages_from_octets(int n_octets)
{
unsigned int n_pages = n_octets / SMSCB_RAW_PAGE_LEN;
if (n_octets % SMSCB_RAW_PAGE_LEN)
n_pages++;
return n_pages;
}
/* parse a smscb.schema.json/payload_decoded type */
static int parse_payload_decoded(struct smscb_message *out, json_t *jtmp, const char **errstr)
{
const char *cset_str, *lang_str, *data_utf8_str;
int rc, dcs_class = 0;
/* character set */
cset_str = json_get_string(jtmp, "character_set");
if (!cset_str) {
*errstr = "Currently 'character_set' is mandatory";
/* TODO: dynamically decide? */
return -EINVAL;
}
/* language */
lang_str = json_get_string(jtmp, "language");
if (lang_str && strlen(lang_str) > 2) {
*errstr = "Only two-digit 'language' code is supported";
return -EINVAL;
}
/* DCS class: if not present, default (0) above will prevail */
rc = json_get_integer_range(&dcs_class, jtmp, "dcs_class", 0, 3);
if (rc < 0 && rc != -ENOENT) {
*errstr = "'dcs_class' out of range";
return rc;
}
data_utf8_str = json_get_string(jtmp, "data_utf8");
if (!data_utf8_str) {
*errstr = "'data_utf8' is mandatory";
return -EINVAL;
}
/* encode according to character set */
if (!strcmp(cset_str, "gsm")) {
if (lang_str) {
rc = get_string_value(iso639_1_cbs_dcs_vals, lang_str);
if (rc >= 0)
out->cbs.dcs = rc;
else {
/* TODO: we must encode it in the first 3 characters */
out->cbs.dcs = 0x0f;
}
} else {
if (json_object_get(jtmp, "dcs_class")) {
/* user has not specified language but class,
* express class in DCS */
out->cbs.dcs = 0xF0 | (dcs_class & 3);
} else {
/* user has specified neither language nor class,
* use general "7 bit alphabet / language unspacified" */
out->cbs.dcs = 0x0F;
}
}
/* convert from UTF-8 input to GSM 7bit output */
rc = charset_utf8_to_gsm7((uint8_t *) out->cbs.data, sizeof(out->cbs.data),
data_utf8_str, strlen(data_utf8_str));
if (rc > 0) {
out->cbs.data_user_len = rc;
out->cbs.num_pages = pages_from_octets(rc);
}
} else if (!strcmp(cset_str, "8bit")) {
/* Determine DCS based on UDH + message class */
out->cbs.dcs = 0xF4 | (dcs_class & 3);
/* copy 8bit data over (hex -> binary conversion) */
rc = osmo_hexparse(data_utf8_str, (uint8_t *)out->cbs.data, sizeof(out->cbs.data));
if (rc > 0)
out->cbs.num_pages = pages_from_octets(rc);
} else if (!strcmp(cset_str, "ucs2")) {
if (lang_str) {
/* TODO: we must encode it in the first two octets */
}
/* convert from UTF-8 input to UCS2 output */
rc = charset_utf8_to_ucs2((uint8_t *) out->cbs.data, sizeof(out->cbs.data),
data_utf8_str, strlen(data_utf8_str));
if (rc > 0)
out->cbs.num_pages = pages_from_octets(rc);
} else {
*errstr = "Invalid 'character_set'";
return -EINVAL;
}
return 0;
}
/* parse a smscb.schema.json/payload type */
static int json2payload(struct smscb_message *out, json_t *in, const char **errstr)
{
json_t *jtmp;
int rc;
if (!in || !json_is_object(in)) {
*errstr = "'payload' must be JSON object";
return -EINVAL;
}
if ((jtmp = json_object_get(in, "payload_encoded"))) {
json_t *jpage_arr, *jpage;
int i, dcs, num_pages, len;
out->is_etws = false;
/* Data Coding Scheme */
rc = json_get_integer_range(&dcs, jtmp, "dcs", 0, 255);
if (rc < 0) {
*errstr = "'dcs' out of range";
return rc;
}
out->cbs.dcs = dcs;
/* Array of Pages as hex-strings */
jpage_arr = json_object_get(jtmp, "pages");
if (!jpage_arr || !json_is_array(jpage_arr)) {
*errstr = "'pages' absent or not an array";
return -EINVAL;
}
num_pages = json_array_size(jpage_arr);
if (num_pages < 1 || num_pages > 15) {
*errstr = "'pages' array size out of range";
return -EINVAL;
}
out->cbs.num_pages = num_pages;
out->cbs.data_user_len = 0;
json_array_foreach(jpage_arr, i, jpage) {
const char *hexstr;
if (!json_is_string(jpage)) {
*errstr = "'pages' array must contain strings";
return -EINVAL;
}
hexstr = json_string_value(jpage);
if (strlen(hexstr) > 88 * 2) {
*errstr = "'pages' array must contain strings up to 88 hex nibbles";
return -EINVAL;
}
len = osmo_hexparse(hexstr, out->cbs.data[i], sizeof(out->cbs.data[i]));
if (len < 0) {
*errstr = "'pages' array must contain hex strings";
return -EINVAL;
}
out->cbs.data_user_len += len;
}
return 0;
} else if ((jtmp = json_object_get(in, "payload_decoded"))) {
out->is_etws = false;
return parse_payload_decoded(out, jtmp, errstr);
} else if ((jtmp = json_object_get(in, "payload_etws"))) {
json_t *jwtype, *jtmp2;
const char *wsecinfo_str;
out->is_etws = true;
/* Warning Type (value) */
jwtype = json_object_get(jtmp, "warning_type");
if (!jwtype) {
*errstr = "'warning_type' must be object";
return -EINVAL;
}
rc = parse_warning_type(jwtype, errstr);
if (rc < 0)
return -EINVAL;
out->etws.warning_type = rc;
/* Emergency User Alert */
jtmp2 = json_object_get(jtmp, "emergency_user_alert");
if (jtmp && json_is_true(jtmp2))
out->etws.user_alert = true;
else
out->etws.user_alert = false;
/* Popup */
jtmp2 = json_object_get(jtmp, "popup_on_display");
if (jtmp && json_is_true(jtmp2))
out->etws.popup_on_display = true;
else
out->etws.popup_on_display = false;
/* Warning Security Info */
wsecinfo_str = json_get_string(jtmp, "warning_sec_info");
if (wsecinfo_str) {
if (osmo_hexparse(wsecinfo_str, out->etws.warning_sec_info,
sizeof(out->etws.warning_sec_info)) < 0) {
*errstr = "'warnin_sec_info' must be hex string";
return -EINVAL;
}
}
return 0;
} else {
*errstr = "'payload_type_encoded', 'payload_type_decoded' or 'payload_etws' must be present";
return -EINVAL;
}
}
/* decode a "smscb.schema.json#definitions/smscb_message" */
static int json2smscb_message(struct smscb_message *out, json_t *in, const char **errstr)
{
json_t *jser_nr, *jtmp;
int msg_id, rc;
if (!json_is_object(in)) {
*errstr = "not a JSON object";
return -EINVAL;
}
jser_nr = json_object_get(in, "serial_nr");
if (!jser_nr) {
*errstr = "serial_nr is mandatory";
return -EINVAL;
}
if (json2serial_nr(&out->serial_nr, jser_nr, errstr) < 0)
return -EINVAL;
rc = json_get_integer_range(&msg_id, in, "message_id", 0, UINT16_MAX);
if (rc < 0) {
*errstr = "message_id out of range";
return -EINVAL;
}
out->message_id = msg_id;
jtmp = json_object_get(in, "payload");
if (json2payload(out, jtmp, errstr) < 0)
return -EINVAL;
return 0;
}
static const struct value_string category_str_vals[] = {
{ CBSP_CATEG_NORMAL, "normal" },
{ CBSP_CATEG_HIGH_PRIO, "high_priority" },
{ CBSP_CATEG_BACKGROUND, "background" },
{ 0, NULL }
};
/* decode a "cbc.schema.json#definitions/cbc_message" */
static int json2cbc_message(struct cbc_message *out, void *ctx, json_t *in, const char **errstr)
{
const char *category_str, *cbe_str;
json_t *jtmp;
int rc, tmp;
if (!json_is_object(in)) {
*errstr = "CBCMSG must be JSON object";
return -EINVAL;
}
/* CBE name (M) */
cbe_str = json_get_string(in, "cbe_name");
if (!cbe_str) {
*errstr = "CBCMSG 'cbe_name' is mandatory";
return -EINVAL;
}
out->cbe_name = talloc_strdup(ctx, cbe_str);
/* Category (O) */
category_str = json_get_string(in, "category");
if (!category_str)
out->priority = CBSP_CATEG_NORMAL;
else {
rc = get_string_value(category_str_vals, category_str);
if (rc < 0) {
*errstr = "CBCMSG 'category' unknown";
return -EINVAL;
}
out->priority = rc;
}
/* Repetition Period (O) */
rc = json_get_integer_range(&tmp, in, "repetition_period", 0, 4095);
if (rc == 0)
out->rep_period = tmp;
else if (rc == -ENOENT){
*errstr = "CBCMSG 'repetiton_period' is mandatory";
return rc;
} else {
*errstr = "CBCMSG 'repetiton_period' out of range";
return rc;
}
/* Number of Broadcasts (O) */
rc = json_get_integer_range(&tmp, in, "num_of_bcast", 0, 65535);
if (rc == 0)
out->num_bcast = tmp;
else if (rc == -ENOENT)
out->num_bcast = 0; /* unlimited */
else {
*errstr = "CBCMSG 'num_of_bcast' out of range";
return rc;
}
/* Warning Period in seconds (O) */
rc = json_get_integer_range(&tmp, in, "warning_period_sec", 0, 65535);
if (rc == 0)
out->warning_period_sec = tmp;
else if (rc == -ENOENT)
out->warning_period_sec = 0xffffffff; /* infinite */
else {
*errstr = "CBCMSG 'warning_period_sec' out of range";
return rc;
}
/* [Geographic] Scope (M) */
jtmp = json_object_get(in, "scope");
if (!jtmp) {
*errstr = "CBCMSG 'scope' is mandatory";
return -EINVAL;
}
if ((jtmp = json_object_get(jtmp, "scope_plmn"))) {
out->scope = CBC_MSG_SCOPE_PLMN;
} else {
*errstr = "CBCMSG only 'scope_plmn' supported";
return -EINVAL;
}
/* SMSCB message itself */
jtmp = json_object_get(in, "smscb_message");
if (!jtmp) {
*errstr = "CBCMSG 'smscb_message' is mandatory";
return -EINVAL;
}
rc = json2smscb_message(&out->msg, jtmp, errstr);
if (rc < 0)
return rc;
return 0;
}
static int api_cb_message_post(const struct _u_request *req, struct _u_response *resp, void *user_data)
{
struct rest_it_op *riop = talloc_zero(g_cbc, struct rest_it_op);
const char *errstr = "Unknown";
json_error_t json_err;
json_t *json_req = NULL;
char *jsonstr;
int rc;
if (!riop) {
LOGP(DREST, LOGL_ERROR, "Out of memory\n");
ulfius_set_string_body_response(resp, 500, "Out of memory");
return U_CALLBACK_COMPLETE;
}
riop->operation = REST_IT_OP_MSG_CREATE;
json_req = ulfius_get_json_body_request(req, &json_err);
if (!json_req) {
errstr = "REST: No JSON Body";
goto err;
}
char *jsontxt = json_dumps(json_req, 0);
LOGP(DREST, LOGL_DEBUG, "/message POST: %s\n", jsontxt);
free(jsontxt);
rc = json2cbc_message(&riop->u.create.cbc_msg, riop, json_req, &errstr);
if (rc < 0)
goto err;
LOGP(DREST, LOGL_DEBUG, "sending as inter-thread op\n");
/* request message to be added by main thread */
rc = rest_it_op_send_and_wait(riop);
if (rc < 0) {
LOGP(DREST, LOGL_ERROR, "Error %d in inter-thread op\n", rc);
errstr = "Error in it_queue";
goto err;
}
json_decref(json_req);
LOGP(DREST, LOGL_DEBUG, "/message POST -> %u (%s)\n",
riop->http_result.response_code, riop->http_result.message);
ulfius_set_string_body_response(resp, riop->http_result.response_code, riop->http_result.message);
talloc_free(riop);
return U_CALLBACK_COMPLETE;
err:
jsonstr = json_dumps(json_req, 0);
LOGP(DREST, LOGL_ERROR, "ERROR: %s (%s)\n", errstr, jsonstr);
free(jsonstr);
json_decref(json_req);
talloc_free(riop);
LOGP(DREST, LOGL_DEBUG, "/message POST -> 400\n");
ulfius_set_string_body_response(resp, 400, errstr);
return U_CALLBACK_COMPLETE;
}
static int api_cb_message_del(const struct _u_request *req, struct _u_response *resp, void *user_data)
{
const char *message_id_str = u_map_get(req->map_url, "message_id");
struct rest_it_op *riop = talloc_zero(g_cbc, struct rest_it_op);
int message_id;
int status = 404;
int rc;
if (!message_id_str) {
status = 400;
goto err;
}
message_id = atoi(message_id_str);
if (message_id < 0 || message_id > 65535) {
status = 400;
goto err;
}
if (!riop) {
status = 500;
goto err;
}
riop->operation = REST_IT_OP_MSG_DELETE;
riop->u.del.msg_id = message_id;
/* request message to be deleted by main thread */
rc = rest_it_op_send_and_wait(riop);
if (rc < 0)
goto err;
LOGP(DREST, LOGL_DEBUG, "/message DELETE(%u) -> %u (%s)\n", message_id,
riop->http_result.response_code, riop->http_result.message);
ulfius_set_string_body_response(resp, riop->http_result.response_code, riop->http_result.message);
talloc_free(riop);
return U_CALLBACK_COMPLETE;
err:
talloc_free(riop);
ulfius_set_empty_body_response(resp, status);
return U_CALLBACK_COMPLETE;
}
static const struct _u_endpoint api_endpoints[] = {
/* create/update a message */
{ "POST", PREFIX, "/message", 0, &api_cb_message_post, NULL },
{ "DELETE", PREFIX, "/message/:message_id", 0, &api_cb_message_del, NULL },
};
static struct _u_instance g_instance;
#ifdef ULFIUS_MALLOC_NOT_BROKEN
static void *g_tall_rest;
static pthread_mutex_t g_tall_rest_lock = PTHREAD_MUTEX_INITIALIZER;
static void *my_o_malloc(size_t sz)
{
void *obj;
pthread_mutex_lock(&g_tall_rest_lock);
obj = talloc_size(g_tall_rest, sz);
pthread_mutex_unlock(&g_tall_rest_lock);
return obj;
}
static void *my_o_realloc(void *obj, size_t sz)
{
void *ret;
pthread_mutex_lock(&g_tall_rest_lock);
ret = talloc_realloc_size(g_tall_rest, obj, sz);
pthread_mutex_unlock(&g_tall_rest_lock);
return ret;
}
static void my_o_free(void *obj)
{
pthread_mutex_lock(&g_tall_rest_lock);
talloc_free(obj);
pthread_mutex_unlock(&g_tall_rest_lock);
}
#endif
int rest_api_init(void *ctx, const char *bind_addr, uint16_t port)
{
struct osmo_sockaddr_str sastr;
int i;
LOGP(DREST, LOGL_INFO, "Main thread tid: %lu\n", pthread_self());
#ifdef ULFIUS_MALLOC_NOT_BROKEN
/* See https://github.com/babelouest/ulfius/issues/63 */
g_tall_rest = ctx;
o_set_alloc_funcs(my_o_malloc, my_o_realloc, my_o_free);
#endif
OSMO_STRLCPY_ARRAY(sastr.ip, bind_addr);
sastr.port = port;
if (strchr(bind_addr, ':')) {
#if (ULFIUS_VERSION_MAJOR > 2) || (ULFIUS_VERSION_MAJOR == 2) && (ULFIUS_VERSION_MINOR >= 6)
struct sockaddr_in6 sin6;
sastr.af = AF_INET6;
osmo_sockaddr_str_to_sockaddr_in6(&sastr, &sin6);
if (ulfius_init_instance_ipv6(&g_instance, port, &sin6, U_USE_IPV6, NULL) != U_OK)
return -1;
#else
LOGP(DREST, LOGL_FATAL, "IPv6 requires ulfius version >= 2.6\n");
return -2;
#endif
} else {
struct sockaddr_in sin;
sastr.af = AF_INET;
osmo_sockaddr_str_to_sockaddr_in(&sastr, &sin);
if (ulfius_init_instance(&g_instance, port, &sin, NULL) != U_OK)
return -1;
}
g_instance.mhd_response_copy_data = 1;
for (i = 0; i < ARRAY_SIZE(api_endpoints); i++)
ulfius_add_endpoint(&g_instance, &api_endpoints[i]);
if (ulfius_start_framework(&g_instance) != U_OK) {
LOGP(DREST, LOGL_FATAL, "Cannot start ECBE REST API at %s:%u\n", bind_addr, port);
return -1;
}
LOGP(DREST, LOGL_NOTICE, "Started ECBE REST API at %s:%u\n", bind_addr, port);
return 0;
}
void rest_api_fin(void)
{
ulfius_stop_framework(&g_instance);
ulfius_clean_instance(&g_instance);
}
View Git Blame Copy Permalink