blob: 3ca87a4b8f606d8a0f06ba5d22c4846d37cd0833 [file] [log] [blame]
Alexander Couzens6a161492020-07-12 13:45:50 +02001/*! \file gprs_ns2.c
2 * GPRS Networks Service (NS) messages on the Gb interface.
3 * 3GPP TS 08.16 version 8.0.1 Release 1999 / ETSI TS 101 299 V8.0.1 (2002-05)
4 * as well as its successor 3GPP TS 48.016 */
5
6/* (C) 2009-2018 by Harald Welte <laforge@gnumonks.org>
7 * (C) 2016-2017,2020 sysmocom - s.f.m.c. GmbH
8 * Author: Alexander Couzens <lynxis@fe80.eu>
9 *
10 *
11 * All Rights Reserved
12 *
13 * SPDX-License-Identifier: GPL-2.0+
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 *
28 */
29
30/*! \addtogroup libgb
31 * @{
32 *
33 * GPRS Networks Service (NS) messages on the Gb interface
34 * 3GPP TS 08.16 version 8.0.1 Release 1999 / ETSI TS 101 299 V8.0.1 (2002-05)
35 *
36 * Some introduction into NS: NS is used typically on top of frame relay,
37 * but in the ip.access world it is encapsulated in UDP packets. It serves
38 * as an intermediate shim betwen BSSGP and the underlying medium. It doesn't
39 * do much, apart from providing congestion notification and status indication.
40 *
41 * Terms:
42 *
43 * NS Network Service
44 * NSVC NS Virtual Connection
45 * NSEI NS Entity Identifier
46 * NSVL NS Virtual Link
47 * NSVLI NS Virtual Link Identifier
48 * BVC BSSGP Virtual Connection
49 * BVCI BSSGP Virtual Connection Identifier
50 * NSVCG NS Virtual Connection Goup
51 * Blocked NS-VC cannot be used for user traffic
52 * Alive Ability of a NS-VC to provide communication
53 *
54 * There can be multiple BSSGP virtual connections over one (group of) NSVC's. BSSGP will
55 * therefore identify the BSSGP virtual connection by a BVCI passed down to NS.
56 * NS then has to figure out which NSVC's are responsible for this BVCI.
57 * Those mappings are administratively configured.
58 *
59 * This implementation has the following limitations:
Alexander Couzens6a161492020-07-12 13:45:50 +020060 * - NSVCI 65535 and 65534 are reserved for internal use
Alexander Couzens6a161492020-07-12 13:45:50 +020061 * - There are no BLOCK and UNBLOCK timers (yet?)
62 *
63 * \file gprs_ns2.c */
64
65#include <stdlib.h>
66#include <unistd.h>
67#include <errno.h>
68#include <stdint.h>
69
70#include <sys/types.h>
71#include <sys/socket.h>
72#include <arpa/inet.h>
73
74#include <osmocom/core/fsm.h>
Daniel Willmann751977b2020-12-02 18:59:44 +010075#include <osmocom/core/logging.h>
Alexander Couzens6a161492020-07-12 13:45:50 +020076#include <osmocom/core/msgb.h>
77#include <osmocom/core/rate_ctr.h>
78#include <osmocom/core/socket.h>
79#include <osmocom/core/sockaddr_str.h>
80#include <osmocom/core/stats.h>
81#include <osmocom/core/stat_item.h>
82#include <osmocom/core/talloc.h>
83#include <osmocom/gprs/gprs_msgb.h>
84#include <osmocom/gsm/prim.h>
85#include <osmocom/gsm/tlv.h>
86
87#include "gprs_ns2_internal.h"
88
89#define ns_set_state(ns_, st_) ns_set_state_with_log(ns_, st_, false, __FILE__, __LINE__)
90#define ns_set_remote_state(ns_, st_) ns_set_state_with_log(ns_, st_, true, __FILE__, __LINE__)
91#define ns_mark_blocked(ns_) ns_set_state(ns_, (ns_)->state | NSE_S_BLOCKED)
92#define ns_mark_unblocked(ns_) ns_set_state(ns_, (ns_)->state & (~NSE_S_BLOCKED));
93#define ns_mark_alive(ns_) ns_set_state(ns_, (ns_)->state | NSE_S_ALIVE)
94#define ns_mark_dead(ns_) ns_set_state(ns_, (ns_)->state & (~NSE_S_ALIVE));
95
96/* HACK: The NS_IE_IP_ADDR does not follow any known TLV rules.
97 * Since it's a hard ABI break to implement 16 bit tag with fixed length entries to workaround it,
98 * the parser will be called with ns_att_tlvdef1 and if it's failed with ns_att_tlvdef2.
99 * The TLV parser depends on 8bit tag in many places.
100 * The NS_IE_IP_ADDR is only valid for SNS_ACK SNS_ADD and SNS_DELETE.
101 */
102static const struct tlv_definition ns_att_tlvdef1 = {
103 .def = {
104 [NS_IE_CAUSE] = { TLV_TYPE_TvLV, 0 },
105 [NS_IE_VCI] = { TLV_TYPE_TvLV, 0 },
106 [NS_IE_PDU] = { TLV_TYPE_TvLV, 0 },
107 [NS_IE_BVCI] = { TLV_TYPE_TvLV, 0 },
108 [NS_IE_NSEI] = { TLV_TYPE_TvLV, 0 },
109 [NS_IE_IPv4_LIST] = { TLV_TYPE_TvLV, 0 },
110 [NS_IE_IPv6_LIST] = { TLV_TYPE_TvLV, 0 },
111 [NS_IE_MAX_NR_NSVC] = { TLV_TYPE_FIXED, 2 },
112 [NS_IE_IPv4_EP_NR] = { TLV_TYPE_FIXED, 2 },
113 [NS_IE_IPv6_EP_NR] = { TLV_TYPE_FIXED, 2 },
114 [NS_IE_RESET_FLAG] = { TLV_TYPE_TV, 0 },
115 /* NS_IE_IP_ADDR in the IPv4 version */
116 [NS_IE_IP_ADDR] = { TLV_TYPE_FIXED, 5 },
117 },
118};
119
120static const struct tlv_definition ns_att_tlvdef2 = {
121 .def = {
122 [NS_IE_CAUSE] = { TLV_TYPE_TvLV, 0 },
123 [NS_IE_VCI] = { TLV_TYPE_TvLV, 0 },
124 [NS_IE_PDU] = { TLV_TYPE_TvLV, 0 },
125 [NS_IE_BVCI] = { TLV_TYPE_TvLV, 0 },
126 [NS_IE_NSEI] = { TLV_TYPE_TvLV, 0 },
127 [NS_IE_IPv4_LIST] = { TLV_TYPE_TvLV, 0 },
128 [NS_IE_IPv6_LIST] = { TLV_TYPE_TvLV, 0 },
129 [NS_IE_MAX_NR_NSVC] = { TLV_TYPE_FIXED, 2 },
130 [NS_IE_IPv4_EP_NR] = { TLV_TYPE_FIXED, 2 },
131 [NS_IE_IPv6_EP_NR] = { TLV_TYPE_FIXED, 2 },
132 [NS_IE_RESET_FLAG] = { TLV_TYPE_TV, 0 },
133 /* NS_IE_IP_ADDR in the IPv6 version */
134 [NS_IE_IP_ADDR] = { TLV_TYPE_FIXED, 17 },
135 },
136};
137
138
139/* Section 10.3.2, Table 13 */
Alexander Couzensb3b837c2020-10-27 15:12:25 +0100140const struct value_string gprs_ns2_cause_strs[] = {
Alexander Couzens6a161492020-07-12 13:45:50 +0200141 { NS_CAUSE_TRANSIT_FAIL, "Transit network failure" },
142 { NS_CAUSE_OM_INTERVENTION, "O&M intervention" },
143 { NS_CAUSE_EQUIP_FAIL, "Equipment failure" },
144 { NS_CAUSE_NSVC_BLOCKED, "NS-VC blocked" },
145 { NS_CAUSE_NSVC_UNKNOWN, "NS-VC unknown" },
146 { NS_CAUSE_BVCI_UNKNOWN, "BVCI unknown" },
147 { NS_CAUSE_SEM_INCORR_PDU, "Semantically incorrect PDU" },
148 { NS_CAUSE_PDU_INCOMP_PSTATE, "PDU not compatible with protocol state" },
149 { NS_CAUSE_PROTO_ERR_UNSPEC, "Protocol error, unspecified" },
150 { NS_CAUSE_INVAL_ESSENT_IE, "Invalid essential IE" },
151 { NS_CAUSE_MISSING_ESSENT_IE, "Missing essential IE" },
152 { NS_CAUSE_INVAL_NR_IPv4_EP, "Invalid Number of IPv4 Endpoints" },
153 { NS_CAUSE_INVAL_NR_IPv6_EP, "Invalid Number of IPv6 Endpoints" },
154 { NS_CAUSE_INVAL_NR_NS_VC, "Invalid Number of NS-VCs" },
155 { NS_CAUSE_INVAL_WEIGH, "Invalid Weights" },
156 { NS_CAUSE_UNKN_IP_EP, "Unknown IP Endpoint" },
157 { NS_CAUSE_UNKN_IP_ADDR, "Unknown IP Address" },
158 { NS_CAUSE_UNKN_IP_TEST_FAILED, "IP Test Failed" },
159 { 0, NULL }
160};
161
Alexander Couzens6a161492020-07-12 13:45:50 +0200162static const struct rate_ctr_desc nsvc_ctr_description[] = {
163 { "packets:in", "Packets at NS Level ( In)" },
164 { "packets:out","Packets at NS Level (Out)" },
165 { "bytes:in", "Bytes at NS Level ( In)" },
166 { "bytes:out", "Bytes at NS Level (Out)" },
167 { "blocked", "NS-VC Block count " },
168 { "dead", "NS-VC gone dead count " },
169 { "replaced", "NS-VC replaced other count" },
170 { "nsei-chg", "NS-VC changed NSEI count " },
171 { "inv-nsvci", "NS-VCI was invalid count " },
172 { "inv-nsei", "NSEI was invalid count " },
173 { "lost:alive", "ALIVE ACK missing count " },
174 { "lost:reset", "RESET ACK missing count " },
175};
176
177static const struct rate_ctr_group_desc nsvc_ctrg_desc = {
178 .group_name_prefix = "ns:nsvc",
179 .group_description = "NSVC Peer Statistics",
180 .num_ctr = ARRAY_SIZE(nsvc_ctr_description),
181 .ctr_desc = nsvc_ctr_description,
182 .class_id = OSMO_STATS_CLASS_PEER,
183};
184
185
186static const struct osmo_stat_item_desc nsvc_stat_description[] = {
187 { "alive.delay", "ALIVE response time ", "ms", 16, 0 },
188};
189
190static const struct osmo_stat_item_group_desc nsvc_statg_desc = {
191 .group_name_prefix = "ns.nsvc",
192 .group_description = "NSVC Peer Statistics",
193 .num_items = ARRAY_SIZE(nsvc_stat_description),
194 .item_desc = nsvc_stat_description,
195 .class_id = OSMO_STATS_CLASS_PEER,
196};
197
Alexander Couzens2498f1d2020-10-27 01:09:01 +0100198const struct value_string gprs_ns2_aff_cause_prim_strs[] = {
199 { NS_AFF_CAUSE_VC_FAILURE, "NSVC failure" },
200 { NS_AFF_CAUSE_VC_RECOVERY, "NSVC recovery" },
201 { NS_AFF_CAUSE_FAILURE, "NSE failure" },
202 { NS_AFF_CAUSE_RECOVERY, "NSE recovery" },
203 { NS_AFF_CAUSE_SNS_CONFIGURED, "NSE SNS configured" },
204 { NS_AFF_CAUSE_SNS_FAILURE, "NSE SNS failure" },
205 { 0, NULL }
206};
207
Alexander Couzens0ab028c2020-11-04 02:41:44 +0100208const struct value_string gprs_ns2_prim_strs[] = {
Alexander Couzens2498f1d2020-10-27 01:09:01 +0100209 { PRIM_NS_UNIT_DATA, "UNIT DATA" },
210 { PRIM_NS_CONGESTION, "CONGESTION" },
211 { PRIM_NS_STATUS, "STATUS" },
212 { 0, NULL }
213};
214
Harald Weltea24e7ee2020-11-29 17:38:48 +0100215const struct value_string gprs_ns2_lltype_strs[] = {
216 { GPRS_NS2_LL_UDP, "UDP" },
217 { GPRS_NS2_LL_FR_GRE, "FR_GRE" },
218 { GPRS_NS2_LL_FR, "FR" },
219 { 0, NULL }
220};
221
Harald Welte5bef2cc2020-09-18 22:33:24 +0200222/*! string-format a given NS-VC into a user-supplied buffer.
223 * \param[in] buf user-allocated output buffer
224 * \param[in] buf_len size of user-allocated output buffer in bytes
225 * \param[in] nsvc NS-VC to be string-formatted
226 * \return pointer to buf on success; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200227char *gprs_ns2_ll_str_buf(char *buf, size_t buf_len, struct gprs_ns2_vc *nsvc)
228{
Alexander Couzens9a4cf272020-10-11 20:48:04 +0200229 const struct osmo_sockaddr *local;
230 const struct osmo_sockaddr *remote;
Alexander Couzens6a161492020-07-12 13:45:50 +0200231 struct osmo_sockaddr_str local_str;
232 struct osmo_sockaddr_str remote_str;
233
234 if (!buf_len)
Harald Welte92ad0292020-09-18 22:34:24 +0200235 return NULL;
Alexander Couzens6a161492020-07-12 13:45:50 +0200236
Alexander Couzensaac90162020-11-19 02:44:04 +0100237 switch (nsvc->nse->ll) {
Alexander Couzens24a14ac2020-11-19 02:34:49 +0100238 case GPRS_NS2_LL_UDP:
Alexander Couzens6a161492020-07-12 13:45:50 +0200239 if (!gprs_ns2_is_ip_bind(nsvc->bind)) {
240 buf[0] = '\0';
241 return buf;
242 }
243
244 local = gprs_ns2_ip_bind_sockaddr(nsvc->bind);
Alexander Couzensc4229a42020-10-11 20:58:04 +0200245 remote = gprs_ns2_ip_vc_remote(nsvc);
Alexander Couzens6a161492020-07-12 13:45:50 +0200246 if (osmo_sockaddr_str_from_sockaddr(&local_str, &local->u.sas))
247 strcpy(local_str.ip, "invalid");
248 if (osmo_sockaddr_str_from_sockaddr(&remote_str, &remote->u.sas))
249 strcpy(remote_str.ip, "invalid");
250
251 if (nsvc->nsvci_is_valid)
252 snprintf(buf, buf_len, "udp)[%s]:%u<%u>[%s]:%u",
253 local_str.ip, local_str.port,
254 nsvc->nsvci,
255 remote_str.ip, remote_str.port);
256 else
257 snprintf(buf, buf_len, "udp)[%s]:%u<>[%s]:%u",
258 local_str.ip, local_str.port,
259 remote_str.ip, remote_str.port);
260 break;
Alexander Couzens24a14ac2020-11-19 02:34:49 +0100261 case GPRS_NS2_LL_FR_GRE:
Alexander Couzens6a161492020-07-12 13:45:50 +0200262 snprintf(buf, buf_len, "frgre)");
263 break;
Alexander Couzens24a14ac2020-11-19 02:34:49 +0100264 case GPRS_NS2_LL_FR:
Alexander Couzens841817e2020-11-19 00:41:29 +0100265 snprintf(buf, buf_len, "fr)netif: %s dlci: %u", gprs_ns2_fr_bind_netif(nsvc->bind),
266 gprs_ns2_fr_nsvc_dlci(nsvc));
267 break;
Alexander Couzens6a161492020-07-12 13:45:50 +0200268 default:
Harald Welte6188e002020-12-01 17:20:07 +0100269 snprintf(buf, buf_len, "unknown)");
Alexander Couzens6a161492020-07-12 13:45:50 +0200270 break;
271 }
272
273 buf[buf_len - 1] = '\0';
274
275 return buf;
276}
277
278/* udp is the longest: udp)[IP6]:65536<65536>[IP6]:65536 */
279#define NS2_LL_MAX_STR 4+2*(INET6_ADDRSTRLEN+9)+8
280
Harald Welte5bef2cc2020-09-18 22:33:24 +0200281/*! string-format a given NS-VC to a thread-local static buffer.
282 * \param[in] nsvc NS-VC to be string-formatted
283 * \return pointer to the string on success; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200284const char *gprs_ns2_ll_str(struct gprs_ns2_vc *nsvc)
285{
286 static __thread char buf[NS2_LL_MAX_STR];
287 return gprs_ns2_ll_str_buf(buf, sizeof(buf), nsvc);
288}
289
Harald Welte5bef2cc2020-09-18 22:33:24 +0200290/*! string-format a given NS-VC to a dynamically allocated string.
291 * \param[in] ctx talloc context from which to allocate
292 * \param[in] nsvc NS-VC to be string-formatted
293 * \return pointer to the string on success; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200294char *gprs_ns2_ll_str_c(const void *ctx, struct gprs_ns2_vc *nsvc)
295{
296 char *buf = talloc_size(ctx, NS2_LL_MAX_STR);
297 if (!buf)
298 return buf;
299 return gprs_ns2_ll_str_buf(buf, NS2_LL_MAX_STR, nsvc);
300}
301
Daniel Willmannf1286542020-11-03 23:03:33 +0100302/*! Return the current state name of a given NS-VC to a thread-local static buffer.
303 * \param[in] nsvc NS-VC to return the state of
304 * \return pointer to the string on success; NULL on error */
305const char *gprs_ns2_nsvc_state_name(struct gprs_ns2_vc *nsvc)
306{
307 return osmo_fsm_inst_state_name(nsvc->fi);
308}
309
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100310/* select a signalling NSVC and respect sig_counter
311 * param[out] reset_counter - all counter has to be resetted to their signal weight
312 * return the chosen nsvc or NULL
313 */
314static struct gprs_ns2_vc *ns2_load_sharing_signal(struct gprs_ns2_nse *nse)
315{
316 struct gprs_ns2_vc *nsvc = NULL, *last = NULL, *tmp;
317
318 llist_for_each_entry(tmp, &nse->nsvc, list) {
319 if (tmp->sig_weight == 0)
320 continue;
321 if (!gprs_ns2_vc_is_unblocked(tmp))
322 continue;
323 if (tmp->sig_counter == 0) {
324 last = tmp;
325 continue;
326 }
327
328 tmp->sig_counter--;
329 nsvc = tmp;
330 break;
331 }
332
333 /* all counter were zero, but there are valid nsvc */
334 if (!nsvc && last) {
335 llist_for_each_entry(tmp, &nse->nsvc, list) {
336 tmp->sig_counter = tmp->sig_weight;
337 }
338
339 last->sig_counter--;
340 return last;
341 } else {
342 return nsvc;
343 }
344}
345
346/* 4.4.1 Load Sharing function for the Frame Relay Sub-Network */
347static struct gprs_ns2_vc *ns2_load_sharing_modulor(
348 struct gprs_ns2_nse *nse,
349 uint16_t bvci,
350 uint32_t load_selector)
351{
352 struct gprs_ns2_vc *tmp;
Alexander Couzens8a2a1a42020-12-26 18:00:17 +0100353 uint32_t mod = (bvci + load_selector) % nse->nsvc_count;
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100354 uint32_t i = 0;
355
356 llist_for_each_entry(tmp, &nse->nsvc, list) {
357 if (!gprs_ns2_vc_is_unblocked(tmp))
358 continue;
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100359 if (i == mod)
360 return tmp;
361 i++;
362 }
363
364 return NULL;
365}
366
367/* pick the first available data NSVC - no load sharing */
368struct gprs_ns2_vc *ns2_load_sharing_first(struct gprs_ns2_nse *nse)
369{
370 struct gprs_ns2_vc *nsvc = NULL, *tmp;
371
372 llist_for_each_entry(tmp, &nse->nsvc, list) {
373 if (!gprs_ns2_vc_is_unblocked(tmp))
374 continue;
375 if (tmp->data_weight == 0)
376 continue;
377
378 nsvc = tmp;
379 break;
380 }
381
382 return nsvc;
383}
384
385
386static struct gprs_ns2_vc *ns2_load_sharing(
387 struct gprs_ns2_nse *nse,
388 uint16_t bvci,
389 uint32_t link_selector)
390{
391 struct gprs_ns2_vc *nsvc = NULL;
392
Alexander Couzens8a2a1a42020-12-26 18:00:17 +0100393 switch (nse->ll) {
394 case GPRS_NS2_LL_FR:
395 nsvc = ns2_load_sharing_modulor(nse, bvci, link_selector);
396 break;
397 case GPRS_NS2_LL_UDP:
398 default:
399 if (bvci == 0) {
400 /* signalling */
401 nsvc = ns2_load_sharing_signal(nse);
402 } else {
403 /* data with load sharing parameter */
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100404 nsvc = ns2_load_sharing_first(nse);
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100405 }
Alexander Couzens8a2a1a42020-12-26 18:00:17 +0100406 break;
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100407 }
408
409 return nsvc;
410}
411
Harald Welte5bef2cc2020-09-18 22:33:24 +0200412/*! Receive a primitive from the NS User (Gb).
413 * \param[in] nsi NS instance to which the primitive is issued
414 * \param[in] oph The primitive
415 * \return 0 on success; negative on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200416int gprs_ns2_recv_prim(struct gprs_ns2_inst *nsi, struct osmo_prim_hdr *oph)
417{
Alexander Couzens6a161492020-07-12 13:45:50 +0200418 /* TODO: implement resource distribution */
419 /* TODO: check for empty PDUs which can be sent to Request/Confirm
420 * the IP endpoint */
421 struct osmo_gprs_ns2_prim *nsp;
422 struct gprs_ns2_nse *nse = NULL;
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100423 struct gprs_ns2_vc *nsvc = NULL;
Alexander Couzens6a161492020-07-12 13:45:50 +0200424 uint16_t bvci, nsei;
425 uint8_t sducontrol = 0;
426
427 if (oph->sap != SAP_NS)
428 return -EINVAL;
429
430 nsp = container_of(oph, struct osmo_gprs_ns2_prim, oph);
431
432 if (oph->operation != PRIM_OP_REQUEST || oph->primitive != PRIM_NS_UNIT_DATA)
433 return -EINVAL;
434
435 if (!oph->msg)
436 return -EINVAL;
437
438 bvci = nsp->bvci;
439 nsei = nsp->nsei;
440
441 nse = gprs_ns2_nse_by_nsei(nsi, nsei);
442 if (!nse)
443 return -EINVAL;
444
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +0100445 nsvc = ns2_load_sharing(nse, bvci, nsp->u.unitdata.link_selector);
Alexander Couzens6a161492020-07-12 13:45:50 +0200446
447 /* TODO: send a status primitive back */
448 if (!nsvc)
449 return 0;
450
451 if (nsp->u.unitdata.change == NS_ENDPOINT_REQUEST_CHANGE)
452 sducontrol = 1;
453 else if (nsp->u.unitdata.change == NS_ENDPOINT_CONFIRM_CHANGE)
454 sducontrol = 2;
455
456 return ns2_tx_unit_data(nsvc, bvci, sducontrol, oph->msg);
457}
458
Harald Welte5bef2cc2020-09-18 22:33:24 +0200459/*! Send a STATUS.ind primitive to the specified NS instance user.
460 * \param[in] nsi NS instance on which we operate
461 * \param[in] nsei NSEI to which the statue relates
462 * \param[in] bvci BVCI to which the status relates
463 * \param[in] cause The cause of the status */
Alexander Couzensbf95f0f2020-10-01 22:56:03 +0200464void ns2_prim_status_ind(struct gprs_ns2_nse *nse,
Daniel Willmann15c09a82020-11-03 23:05:43 +0100465 struct gprs_ns2_vc *nsvc,
Alexander Couzensbf95f0f2020-10-01 22:56:03 +0200466 uint16_t bvci,
Alexander Couzens6a161492020-07-12 13:45:50 +0200467 enum gprs_ns2_affecting_cause cause)
468{
Daniel Willmann15c09a82020-11-03 23:05:43 +0100469 char nsvc_str[NS2_LL_MAX_STR];
Alexander Couzens6a161492020-07-12 13:45:50 +0200470 struct osmo_gprs_ns2_prim nsp = {};
Alexander Couzensbf95f0f2020-10-01 22:56:03 +0200471 nsp.nsei = nse->nsei;
Alexander Couzens6a161492020-07-12 13:45:50 +0200472 nsp.bvci = bvci;
473 nsp.u.status.cause = cause;
Alexander Couzens1c8785d2020-12-17 06:58:53 +0100474 nsp.u.status.transfer = ns2_count_transfer_cap(nse, bvci);
Alexander Couzensda0a2852020-10-01 23:24:07 +0200475 nsp.u.status.first = nse->first;
476 nsp.u.status.persistent = nse->persistent;
Daniel Willmann15c09a82020-11-03 23:05:43 +0100477 if (nsvc)
478 nsp.u.status.nsvc = gprs_ns2_ll_str_buf(nsvc_str, sizeof(nsvc_str), nsvc);
479
Alexander Couzens6a161492020-07-12 13:45:50 +0200480 osmo_prim_init(&nsp.oph, SAP_NS, PRIM_NS_STATUS,
481 PRIM_OP_INDICATION, NULL);
Alexander Couzensbf95f0f2020-10-01 22:56:03 +0200482 nse->nsi->cb(&nsp.oph, nse->nsi->cb_data);
Alexander Couzens6a161492020-07-12 13:45:50 +0200483}
484
Harald Welte5bef2cc2020-09-18 22:33:24 +0200485/*! Allocate a NS-VC within the given bind + NSE.
486 * \param[in] bind The 'bind' on which we operate
487 * \param[in] nse The NS Entity on which we operate
488 * \param[in] initiater - if this is an incoming remote (!initiater) or a local outgoing connection (initater)
489 * \return newly allocated NS-VC on success; NULL on error */
Alexander Couzensd923cff2020-12-01 01:03:52 +0100490struct gprs_ns2_vc *ns2_vc_alloc(struct gprs_ns2_vc_bind *bind, struct gprs_ns2_nse *nse, bool initiater,
491 enum gprs_ns2_vc_mode vc_mode)
Alexander Couzens6a161492020-07-12 13:45:50 +0200492{
Daniel Willmannbb899052021-01-16 14:02:45 +0100493 /* Sanity check */
494 OSMO_ASSERT(bind->ll == nse->ll);
495
Alexander Couzens6a161492020-07-12 13:45:50 +0200496 struct gprs_ns2_vc *nsvc = talloc_zero(bind, struct gprs_ns2_vc);
497
498 if (!nsvc)
499 return NULL;
500
501 nsvc->bind = bind;
502 nsvc->nse = nse;
Alexander Couzensd923cff2020-12-01 01:03:52 +0100503 nsvc->mode = vc_mode;
Alexander Couzens6a161492020-07-12 13:45:50 +0200504 nsvc->sig_weight = 1;
505 nsvc->data_weight = 1;
506
507 nsvc->ctrg = rate_ctr_group_alloc(nsvc, &nsvc_ctrg_desc, bind->nsi->rate_ctr_idx);
508 if (!nsvc->ctrg) {
509 goto err;
510 }
511 nsvc->statg = osmo_stat_item_group_alloc(nsvc, &nsvc_statg_desc, bind->nsi->rate_ctr_idx);
512 if (!nsvc->statg)
513 goto err_group;
514 if (!gprs_ns2_vc_fsm_alloc(nsvc, NULL, initiater))
515 goto err_statg;
516
517 bind->nsi->rate_ctr_idx++;
518
519 llist_add(&nsvc->list, &nse->nsvc);
520 llist_add(&nsvc->blist, &bind->nsvc);
521
522 return nsvc;
523
524err_statg:
525 osmo_stat_item_group_free(nsvc->statg);
526err_group:
527 rate_ctr_group_free(nsvc->ctrg);
528err:
529 talloc_free(nsvc);
530
531 return NULL;
532}
533
Harald Welte5bef2cc2020-09-18 22:33:24 +0200534/*! Destroy/release given NS-VC.
535 * \param[in] nsvc NS-VC to destroy */
Alexander Couzens6a161492020-07-12 13:45:50 +0200536void gprs_ns2_free_nsvc(struct gprs_ns2_vc *nsvc)
537{
538 if (!nsvc)
539 return;
540
Daniel Willmann15c09a82020-11-03 23:05:43 +0100541 ns2_prim_status_ind(nsvc->nse, nsvc, 0, NS_AFF_CAUSE_VC_FAILURE);
Alexander Couzens6a161492020-07-12 13:45:50 +0200542
543 llist_del(&nsvc->list);
544 llist_del(&nsvc->blist);
545
546 /* notify nse this nsvc is unavailable */
547 ns2_nse_notify_unblocked(nsvc, false);
548
549 /* check if sns is using this VC */
550 ns2_sns_free_nsvc(nsvc);
551 osmo_fsm_inst_term(nsvc->fi, OSMO_FSM_TERM_REQUEST, NULL);
552
553 /* let the driver/bind clean up it's internal state */
554 if (nsvc->priv && nsvc->bind->free_vc)
555 nsvc->bind->free_vc(nsvc);
556
557 osmo_stat_item_group_free(nsvc->statg);
558 rate_ctr_group_free(nsvc->ctrg);
559
560 talloc_free(nsvc);
561}
562
Alexander Couzens47558792020-12-06 03:16:11 +0100563/*! Destroy/release all NS-VC of given NSE
564 * \param[in] nse NSE
565 */
566void gprs_ns2_free_nsvcs(struct gprs_ns2_nse *nse)
567{
568 struct gprs_ns2_vc *nsvc, *tmp;
569
570 if (!nse)
571 return;
572
573 llist_for_each_entry_safe(nsvc, tmp, &nse->nsvc, list) {
574 gprs_ns2_free_nsvc(nsvc);
575 }
576}
577
Harald Welte5bef2cc2020-09-18 22:33:24 +0200578/*! Allocate a message buffer for use with the NS2 stack. */
Alexander Couzens6a161492020-07-12 13:45:50 +0200579struct msgb *gprs_ns2_msgb_alloc(void)
580{
581 struct msgb *msg = msgb_alloc_headroom(NS_ALLOC_SIZE, NS_ALLOC_HEADROOM,
582 "GPRS/NS");
583 if (!msg) {
584 LOGP(DLNS, LOGL_ERROR, "Failed to allocate NS message of size %d\n",
585 NS_ALLOC_SIZE);
586 }
587 return msg;
588}
589
Harald Welte5bef2cc2020-09-18 22:33:24 +0200590/*! Create a status message to be sent over a new connection.
591 * \param[in] orig_msg the original message
592 * \param[in] tp TLVP parsed of the original message
593 * \param[out] reject callee-allocated message buffer of the generated NS-STATUS
594 * \param[in] cause Cause for the rejection
595 * \return 0 on success */
Alexander Couzens6a161492020-07-12 13:45:50 +0200596static int reject_status_msg(struct msgb *orig_msg, struct tlv_parsed *tp, struct msgb **reject, enum ns_cause cause)
597{
598 struct msgb *msg = gprs_ns2_msgb_alloc();
599 struct gprs_ns_hdr *nsh;
600 bool have_vci = false;
601 uint8_t _cause = cause;
602 uint16_t nsei = 0;
603
604 if (!msg)
605 return -ENOMEM;
606
Harald Welte798efea2020-12-03 16:01:02 +0100607 if (TLVP_PRES_LEN(tp, NS_IE_NSEI, 2)) {
Alexander Couzens6a161492020-07-12 13:45:50 +0200608 nsei = tlvp_val16be(tp, NS_IE_NSEI);
609
610 LOGP(DLNS, LOGL_NOTICE, "NSEI=%u Rejecting message without NSVCI. Tx NS STATUS (cause=%s)\n",
611 nsei, gprs_ns2_cause_str(cause));
612 }
613
614 msg->l2h = msgb_put(msg, sizeof(*nsh));
615 nsh = (struct gprs_ns_hdr *) msg->l2h;
616 nsh->pdu_type = NS_PDUT_STATUS;
617
618 msgb_tvlv_put(msg, NS_IE_CAUSE, 1, &_cause);
Harald Welte798efea2020-12-03 16:01:02 +0100619 have_vci = TLVP_PRES_LEN(tp, NS_IE_VCI, 2);
Alexander Couzens6a161492020-07-12 13:45:50 +0200620
621 /* Section 9.2.7.1: Static conditions for NS-VCI */
622 if (cause == NS_CAUSE_NSVC_BLOCKED ||
623 cause == NS_CAUSE_NSVC_UNKNOWN) {
624 if (!have_vci) {
625 msgb_free(msg);
626 return -EINVAL;
627 }
628
629 msgb_tvlv_put(msg, NS_IE_VCI, 2, TLVP_VAL(tp, NS_IE_VCI));
630 }
631
632 /* Section 9.2.7.2: Static conditions for NS PDU */
633 switch (cause) {
634 case NS_CAUSE_SEM_INCORR_PDU:
635 case NS_CAUSE_PDU_INCOMP_PSTATE:
636 case NS_CAUSE_PROTO_ERR_UNSPEC:
637 case NS_CAUSE_INVAL_ESSENT_IE:
638 case NS_CAUSE_MISSING_ESSENT_IE:
639 msgb_tvlv_put(msg, NS_IE_PDU, msgb_l2len(orig_msg),
640 orig_msg->l2h);
641 break;
642 default:
643 break;
644 }
645
646 *reject = msg;
647 return 0;
648}
649
Harald Welte5bef2cc2020-09-18 22:33:24 +0200650/*! Resolve a NS Entity based on its NSEI.
651 * \param[in] nsi NS Instance in which we do the look-up
652 * \param[in] nsei NSEI to look up
653 * \return NS Entity in successful case; NULL if none found */
Alexander Couzens6a161492020-07-12 13:45:50 +0200654struct gprs_ns2_nse *gprs_ns2_nse_by_nsei(struct gprs_ns2_inst *nsi, uint16_t nsei)
655{
656 struct gprs_ns2_nse *nse;
657
658 llist_for_each_entry(nse, &nsi->nse, list) {
659 if (nse->nsei == nsei)
660 return nse;
661 }
662
663 return NULL;
664}
665
Harald Welte5bef2cc2020-09-18 22:33:24 +0200666/*! Resolve a NS-VC Entity based on its NS-VCI.
667 * \param[in] nsi NS Instance in which we do the look-up
668 * \param[in] nsvci NS-VCI to look up
669 * \return NS-VC Entity in successful case; NULL if none found */
Alexander Couzens6a161492020-07-12 13:45:50 +0200670struct gprs_ns2_vc *gprs_ns2_nsvc_by_nsvci(struct gprs_ns2_inst *nsi, uint16_t nsvci)
671{
672 struct gprs_ns2_nse *nse;
673 struct gprs_ns2_vc *nsvc;
674
675 llist_for_each_entry(nse, &nsi->nse, list) {
676 llist_for_each_entry(nsvc, &nse->nsvc, list) {
677 if (nsvc->nsvci_is_valid && nsvc->nsvci == nsvci)
678 return nsvc;
679 }
680 }
681
682 return NULL;
683}
684
Harald Welte5bef2cc2020-09-18 22:33:24 +0200685/*! Create a NS Entity within given NS instance.
686 * \param[in] nsi NS instance in which to create NS Entity
687 * \param[in] nsei NS Entity Identifier of to-be-created NSE
688 * \returns newly-allocated NS-E in successful case; NULL on error */
Alexander Couzensd923cff2020-12-01 01:03:52 +0100689struct gprs_ns2_nse *gprs_ns2_create_nse(struct gprs_ns2_inst *nsi, uint16_t nsei,
690 enum gprs_ns2_ll linklayer, enum gprs_ns2_dialect dialect)
Alexander Couzens6a161492020-07-12 13:45:50 +0200691{
692 struct gprs_ns2_nse *nse;
Alexander Couzens93ad4992020-12-06 03:03:03 +0100693 char sns[16];
Alexander Couzens6a161492020-07-12 13:45:50 +0200694
695 nse = gprs_ns2_nse_by_nsei(nsi, nsei);
696 if (nse) {
697 LOGP(DLNS, LOGL_ERROR, "NSEI:%u Can not create a NSE with already taken NSEI\n", nsei);
698 return nse;
699 }
700
701 nse = talloc_zero(nsi, struct gprs_ns2_nse);
702 if (!nse)
703 return NULL;
704
Alexander Couzens93ad4992020-12-06 03:03:03 +0100705 if (dialect == NS2_DIALECT_SNS) {
706 snprintf(sns, sizeof(sns), "NSE%05u-SNS", nsei);
707 nse->bss_sns_fi = ns2_sns_bss_fsm_alloc(nse, sns);
708 if (!nse->bss_sns_fi) {
709 talloc_free(nse);
710 return NULL;
711 }
712 }
713
Alexander Couzensd923cff2020-12-01 01:03:52 +0100714 nse->dialect = dialect;
Alexander Couzensaac90162020-11-19 02:44:04 +0100715 nse->ll = linklayer;
Alexander Couzens6a161492020-07-12 13:45:50 +0200716 nse->nsei = nsei;
717 nse->nsi = nsi;
Alexander Couzensda0a2852020-10-01 23:24:07 +0200718 nse->first = true;
Alexander Couzens6a161492020-07-12 13:45:50 +0200719 llist_add(&nse->list, &nsi->nse);
720 INIT_LLIST_HEAD(&nse->nsvc);
721
722 return nse;
723}
724
Alexander Couzens05e7f7d2020-10-11 19:51:46 +0200725/*! Return the NSEI
726 * \param[in] nse NS Entity
727 * \return the nsei.
728 */
729uint16_t gprs_ns2_nse_nsei(struct gprs_ns2_nse *nse)
730{
731 return nse->nsei;
732}
733
Harald Welte5bef2cc2020-09-18 22:33:24 +0200734/*! Destroy given NS Entity.
735 * \param[in] nse NS Entity to destroy */
Alexander Couzens6a161492020-07-12 13:45:50 +0200736void gprs_ns2_free_nse(struct gprs_ns2_nse *nse)
737{
Alexander Couzens6a161492020-07-12 13:45:50 +0200738 if (!nse)
739 return;
740
Alexander Couzens47558792020-12-06 03:16:11 +0100741 gprs_ns2_free_nsvcs(nse);
Daniel Willmann15c09a82020-11-03 23:05:43 +0100742 ns2_prim_status_ind(nse, NULL, 0, NS_AFF_CAUSE_FAILURE);
Alexander Couzens6a161492020-07-12 13:45:50 +0200743
744 llist_del(&nse->list);
745 if (nse->bss_sns_fi)
746 osmo_fsm_inst_term(nse->bss_sns_fi, OSMO_FSM_TERM_REQUEST, NULL);
747 talloc_free(nse);
748}
749
Alexander Couzens4b6c8af2020-10-11 20:15:25 +0200750void gprs_ns2_free_nses(struct gprs_ns2_inst *nsi)
751{
752 struct gprs_ns2_nse *nse, *ntmp;
753
754 llist_for_each_entry_safe(nse, ntmp, &nsi->nse, list) {
755 gprs_ns2_free_nse(nse);
756 }
757}
758
Alexander Couzens6a161492020-07-12 13:45:50 +0200759static inline int ns2_tlv_parse(struct tlv_parsed *dec,
760 const uint8_t *buf, int buf_len, uint8_t lv_tag,
761 uint8_t lv_tag2)
762{
763 /* workaround for NS_IE_IP_ADDR not following any known TLV rules.
764 * See comment of ns_att_tlvdef1. */
765 int rc = tlv_parse(dec, &ns_att_tlvdef1, buf, buf_len, lv_tag, lv_tag2);
766 if (rc < 0)
767 return tlv_parse(dec, &ns_att_tlvdef2, buf, buf_len, lv_tag, lv_tag2);
768 return rc;
769}
770
771
Harald Welte5bef2cc2020-09-18 22:33:24 +0200772/*! Create a new NS-VC based on a [received] message. Depending on the bind it might create a NSE.
773 * \param[in] bind the bind through which msg was received
774 * \param[in] msg the actual received message
775 * \param[in] logname A name to describe the VC. E.g. ip address pair
776 * \param[out] reject A message filled to be sent back. Only used in failure cases.
777 * \param[out] success A pointer which will be set to the new VC on success
778 * \return enum value indicating the status, e.g. GPRS_NS2_CS_CREATED */
Alexander Couzens6a161492020-07-12 13:45:50 +0200779enum gprs_ns2_cs ns2_create_vc(struct gprs_ns2_vc_bind *bind,
780 struct msgb *msg,
781 const char *logname,
782 struct msgb **reject,
783 struct gprs_ns2_vc **success)
784{
785 struct gprs_ns_hdr *nsh = (struct gprs_ns_hdr *)msg->l2h;
786 struct tlv_parsed tp;
787 struct gprs_ns2_vc *nsvc;
788 struct gprs_ns2_nse *nse;
Alexander Couzensd923cff2020-12-01 01:03:52 +0100789 enum gprs_ns2_dialect dialect;
790 enum gprs_ns2_vc_mode vc_mode;
Alexander Couzens6a161492020-07-12 13:45:50 +0200791 uint16_t nsvci;
792 uint16_t nsei;
793
Alexander Couzens12e5e6b2020-12-10 00:18:17 +0100794 int rc, tlv;
Alexander Couzens6a161492020-07-12 13:45:50 +0200795
796 if (msg->len < sizeof(struct gprs_ns_hdr))
797 return GPRS_NS2_CS_ERROR;
798
Alexander Couzens12e5e6b2020-12-10 00:18:17 +0100799 /* parse the tlv early to allow reject status msg to
800 * work with valid tp.
801 * Ignore the return code until the pdu type is parsed because
802 * an unknown pdu type should be ignored */
803 tlv = ns2_tlv_parse(&tp, nsh->data,
Alexander Couzensbac5b012020-12-09 23:32:22 +0100804 msgb_l2len(msg) - sizeof(*nsh), 0, 0);
Alexander Couzensbac5b012020-12-09 23:32:22 +0100805
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100806 switch (nsh->pdu_type) {
807 case NS_PDUT_STATUS:
Alexander Couzens6a161492020-07-12 13:45:50 +0200808 /* Do not respond, see 3GPP TS 08.16, 7.5.1 */
809 LOGP(DLNS, LOGL_INFO, "Ignoring NS STATUS from %s "
810 "for non-existing NS-VC\n",
811 logname);
812 return GPRS_NS2_CS_SKIPPED;
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100813 case NS_PDUT_ALIVE_ACK:
Alexander Couzens6a161492020-07-12 13:45:50 +0200814 /* Ignore this, see 3GPP TS 08.16, 7.4.1 */
815 LOGP(DLNS, LOGL_INFO, "Ignoring NS ALIVE ACK from %s "
816 "for non-existing NS-VC\n",
817 logname);
818 return GPRS_NS2_CS_SKIPPED;
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100819 case NS_PDUT_RESET_ACK:
Alexander Couzens6a161492020-07-12 13:45:50 +0200820 /* Ignore this, see 3GPP TS 08.16, 7.3.1 */
821 LOGP(DLNS, LOGL_INFO, "Ignoring NS RESET ACK from %s "
822 "for non-existing NS-VC\n",
823 logname);
824 return GPRS_NS2_CS_SKIPPED;
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100825 case NS_PDUT_RESET:
826 /* accept PDU RESET when vc_mode matches */
Alexander Couzensd923cff2020-12-01 01:03:52 +0100827 if (bind->accept_ipaccess) {
828 dialect = NS2_DIALECT_IPACCESS;
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100829 break;
Alexander Couzensd923cff2020-12-01 01:03:52 +0100830 }
Alexander Couzens6a161492020-07-12 13:45:50 +0200831
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100832 rc = reject_status_msg(msg, &tp, reject, NS_CAUSE_PDU_INCOMP_PSTATE);
Alexander Couzens3c22f912020-12-10 00:20:18 +0100833 if (rc < 0)
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100834 LOGP(DLNS, LOGL_ERROR, "Failed to generate reject message (%d)\n", rc);
Alexander Couzensd87a2f12020-11-30 22:20:20 +0100835 return GPRS_NS2_CS_REJECTED;
836 default:
Alexander Couzens8ebc1ac2020-10-12 03:57:26 +0200837 rc = reject_status_msg(msg, &tp, reject, NS_CAUSE_PDU_INCOMP_PSTATE);
Alexander Couzens3c22f912020-12-10 00:20:18 +0100838 if (rc < 0)
Alexander Couzens8ebc1ac2020-10-12 03:57:26 +0200839 LOGP(DLNS, LOGL_ERROR, "Failed to generate reject message (%d)\n", rc);
Alexander Couzens8ebc1ac2020-10-12 03:57:26 +0200840 return GPRS_NS2_CS_REJECTED;
Alexander Couzens6a161492020-07-12 13:45:50 +0200841 }
842
Alexander Couzens12e5e6b2020-12-10 00:18:17 +0100843 if (tlv < 0) {
844 /* TODO: correct behaviour would checking what's wrong.
845 * If it's an essential TLV for the PDU return NS_CAUSE_INVAL_ESSENT_IE.
846 * Otherwise ignore the non-essential TLV. */
847 LOGP(DLNS, LOGL_ERROR, "Rx NS RESET Error %d during "
848 "TLV Parse\n", tlv);
849 rc = reject_status_msg(msg, &tp, reject, NS_CAUSE_PROTO_ERR_UNSPEC);
Alexander Couzens3c22f912020-12-10 00:20:18 +0100850 if (rc < 0)
Alexander Couzens12e5e6b2020-12-10 00:18:17 +0100851 LOGP(DLNS, LOGL_ERROR, "Failed to generate reject message (%d)\n", rc);
Alexander Couzens12e5e6b2020-12-10 00:18:17 +0100852 return GPRS_NS2_CS_REJECTED;
853 }
854
Harald Welte798efea2020-12-03 16:01:02 +0100855 if (!TLVP_PRES_LEN(&tp, NS_IE_CAUSE, 1) ||
856 !TLVP_PRES_LEN(&tp, NS_IE_VCI, 2) || !TLVP_PRES_LEN(&tp, NS_IE_NSEI, 2)) {
Alexander Couzens8ebc1ac2020-10-12 03:57:26 +0200857 LOGP(DLNS, LOGL_ERROR, "NS RESET Missing mandatory IE\n");
858 rc = reject_status_msg(msg, &tp, reject, NS_CAUSE_MISSING_ESSENT_IE);
Alexander Couzens3c22f912020-12-10 00:20:18 +0100859 if (rc < 0)
860 LOGP(DLNS, LOGL_ERROR, "Failed to generate reject message (%d)\n", rc);
Alexander Couzens8ebc1ac2020-10-12 03:57:26 +0200861 return GPRS_NS2_CS_REJECTED;
Alexander Couzens6a161492020-07-12 13:45:50 +0200862 }
863
864 /* find or create NSE */
865 nsei = tlvp_val16be(&tp, NS_IE_NSEI);
866 nse = gprs_ns2_nse_by_nsei(bind->nsi, nsei);
867 if (!nse) {
868 if (!bind->nsi->create_nse) {
869 return GPRS_NS2_CS_SKIPPED;
870 }
871
Alexander Couzensd923cff2020-12-01 01:03:52 +0100872 nse = gprs_ns2_create_nse(bind->nsi, nsei, bind->ll, dialect);
Alexander Couzens6a161492020-07-12 13:45:50 +0200873 if (!nse) {
874 return GPRS_NS2_CS_ERROR;
875 }
876 }
877
Alexander Couzensd923cff2020-12-01 01:03:52 +0100878 vc_mode = gprs_ns2_dialect_to_vc_mode(dialect);
879 nsvc = ns2_vc_alloc(bind, nse, false, vc_mode);
Alexander Couzens6a161492020-07-12 13:45:50 +0200880 if (!nsvc)
881 return GPRS_NS2_CS_SKIPPED;
882
Alexander Couzens6a161492020-07-12 13:45:50 +0200883 nsvci = tlvp_val16be(&tp, NS_IE_VCI);
884 nsvc->nsvci = nsvci;
885 nsvc->nsvci_is_valid = true;
886
887 *success = nsvc;
888
889 return GPRS_NS2_CS_CREATED;
890}
891
Harald Welte5bef2cc2020-09-18 22:33:24 +0200892/*! Create, and connect an inactive, new IP-based NS-VC
893 * \param[in] bind bind in which the new NS-VC is to be created
894 * \param[in] remote remote address to which to connect
895 * \param[in] nse NS Entity in which the NS-VC is to be created
896 * \param[in] nsvci is only required when bind->vc_mode == NS2_VC_MODE_BLOCKRESET
897 * \return pointer to newly-allocated, connected and inactive NS-VC; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200898struct gprs_ns2_vc *gprs_ns2_ip_connect_inactive(struct gprs_ns2_vc_bind *bind,
Vadim Yanitskiya07f25e2020-10-09 21:47:01 +0700899 const struct osmo_sockaddr *remote,
Alexander Couzens6a161492020-07-12 13:45:50 +0200900 struct gprs_ns2_nse *nse,
901 uint16_t nsvci)
902{
903 struct gprs_ns2_vc *nsvc;
904
905 nsvc = gprs_ns2_ip_bind_connect(bind, nse, remote);
906 if (!nsvc)
907 return NULL;
908
909 if (nsvc->mode == NS2_VC_MODE_BLOCKRESET) {
910 nsvc->nsvci = nsvci;
911 nsvc->nsvci_is_valid = true;
912 }
913
914 return nsvc;
915}
916
Harald Welte5bef2cc2020-09-18 22:33:24 +0200917/*! Create, connect and activate a new IP-based NS-VC
918 * \param[in] bind bind in which the new NS-VC is to be created
919 * \param[in] remote remote address to which to connect
920 * \param[in] nse NS Entity in which the NS-VC is to be created
921 * \param[in] nsvci is only required when bind->vc_mode == NS2_VC_MODE_BLOCKRESET
922 * \return pointer to newly-allocated, connected and activated NS-VC; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200923struct gprs_ns2_vc *gprs_ns2_ip_connect(struct gprs_ns2_vc_bind *bind,
Vadim Yanitskiya07f25e2020-10-09 21:47:01 +0700924 const struct osmo_sockaddr *remote,
Alexander Couzens6a161492020-07-12 13:45:50 +0200925 struct gprs_ns2_nse *nse,
926 uint16_t nsvci)
927{
928 struct gprs_ns2_vc *nsvc;
929 nsvc = gprs_ns2_ip_connect_inactive(bind, remote, nse, nsvci);
930 if (!nsvc)
931 return NULL;
932
933 gprs_ns2_vc_fsm_start(nsvc);
934
935 return nsvc;
936}
937
Harald Welte5bef2cc2020-09-18 22:33:24 +0200938/*! Create, connect and activate a new IP-based NS-VC
939 * \param[in] bind bind in which the new NS-VC is to be created
940 * \param[in] remote remote address to which to connect
941 * \param[in] nsei NSEI of the NS Entity in which the NS-VC is to be created
942 * \param[in] nsvci is only required when bind->vc_mode == NS2_VC_MODE_BLOCKRESET
943 * \return pointer to newly-allocated, connected and activated NS-VC; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +0200944struct gprs_ns2_vc *gprs_ns2_ip_connect2(struct gprs_ns2_vc_bind *bind,
Vadim Yanitskiya07f25e2020-10-09 21:47:01 +0700945 const struct osmo_sockaddr *remote,
Alexander Couzens6a161492020-07-12 13:45:50 +0200946 uint16_t nsei,
Alexander Couzensd923cff2020-12-01 01:03:52 +0100947 uint16_t nsvci,
948 enum gprs_ns2_dialect dialect)
Alexander Couzens6a161492020-07-12 13:45:50 +0200949{
950 struct gprs_ns2_nse *nse = gprs_ns2_nse_by_nsei(bind->nsi, nsei);
951
952 if (!nse) {
Alexander Couzensd923cff2020-12-01 01:03:52 +0100953 nse = gprs_ns2_create_nse(bind->nsi, nsei, GPRS_NS2_LL_UDP, dialect);
Alexander Couzens6a161492020-07-12 13:45:50 +0200954 if (!nse)
955 return NULL;
956 }
957
958 return gprs_ns2_ip_connect(bind, remote, nse, nsvci);
959}
960
Harald Welte5bef2cc2020-09-18 22:33:24 +0200961/*! Find NS-VC for given socket address.
962 * \param[in] nse NS Entity in which to search
963 * \param[in] sockaddr socket address to search for
964 * \return NS-VC matching sockaddr; NULL if none found */
Alexander Couzens38b19e82020-09-23 23:56:37 +0200965struct gprs_ns2_vc *gprs_ns2_nsvc_by_sockaddr_nse(struct gprs_ns2_nse *nse,
Vadim Yanitskiya07f25e2020-10-09 21:47:01 +0700966 const struct osmo_sockaddr *sockaddr)
Alexander Couzens6a161492020-07-12 13:45:50 +0200967{
968 struct gprs_ns2_vc *nsvc;
Alexander Couzens9a4cf272020-10-11 20:48:04 +0200969 const struct osmo_sockaddr *remote;
Alexander Couzens6a161492020-07-12 13:45:50 +0200970
971 OSMO_ASSERT(nse);
972 OSMO_ASSERT(sockaddr);
973
974 llist_for_each_entry(nsvc, &nse->nsvc, list) {
Alexander Couzensc4229a42020-10-11 20:58:04 +0200975 remote = gprs_ns2_ip_vc_remote(nsvc);
Alexander Couzens6a161492020-07-12 13:45:50 +0200976 if (!osmo_sockaddr_cmp(sockaddr, remote))
977 return nsvc;
978 }
979
980 return NULL;
981}
982
Alexander Couzens6cb5d5f2020-10-11 23:23:31 +0200983/*!
984 * Iterate over all nsvc of a NS Entity and call the callback.
985 * If the callback returns < 0 it aborts the loop and returns the callback return code.
986 * \param[in] nse NS Entity to iterate over all nsvcs
987 * \param[in] cb the callback to call
988 * \param[inout] cb_data the private data of the callback
989 * \return 0 if the loop completes. If a callback returns < 0 it will returns this value.
990 */
991int gprs_ns2_nse_foreach_nsvc(struct gprs_ns2_nse *nse, gprs_ns2_foreach_nsvc_cb cb, void *cb_data)
992{
993 struct gprs_ns2_vc *nsvc, *tmp;
994 int rc = 0;
995 llist_for_each_entry_safe(nsvc, tmp, &nse->nsvc, list) {
996 rc = cb(nsvc, cb_data);
997 if (rc < 0)
998 return rc;
999 }
1000
1001 return 0;
1002}
1003
1004
Alexander Couzens6a161492020-07-12 13:45:50 +02001005
Harald Welte5bef2cc2020-09-18 22:33:24 +02001006/*! Bottom-side entry-point for received NS PDU from the driver/bind
Harald Welte5bef2cc2020-09-18 22:33:24 +02001007 * \param[in] nsvc NS-VC for which the message was received
1008 * \param msg the received message. Ownership is trasnferred, caller must not free it!
1009 * \return 0 on success; negative on error */
Alexander Couzensffd49d02020-09-24 00:47:17 +02001010int ns2_recv_vc(struct gprs_ns2_vc *nsvc,
Alexander Couzens6a161492020-07-12 13:45:50 +02001011 struct msgb *msg)
1012{
1013 struct gprs_ns_hdr *nsh = (struct gprs_ns_hdr *) msg->l2h;
1014 struct tlv_parsed tp;
1015 int rc = 0;
1016
Daniel Willmann751977b2020-12-02 18:59:44 +01001017 log_set_context(LOG_CTX_GB_NSE, nsvc->nse);
1018 log_set_context(LOG_CTX_GB_NSVC, nsvc);
1019
Alexander Couzens6a161492020-07-12 13:45:50 +02001020 if (msg->len < sizeof(struct gprs_ns_hdr))
1021 return -EINVAL;
1022
1023 switch (nsh->pdu_type) {
1024 case SNS_PDUT_CONFIG:
1025 /* one additional byte ('end flag') before the TLV part starts */
1026 rc = ns2_tlv_parse(&tp, nsh->data+1,
1027 msgb_l2len(msg) - sizeof(*nsh)-1, 0, 0);
1028 if (rc < 0) {
Alexander Couzensbb0a53b2020-10-12 04:18:03 +02001029 LOGP(DLNS, LOGL_NOTICE, "Error during TLV Parse in %s\n", msgb_hexdump(msg));
Alexander Couzens6a161492020-07-12 13:45:50 +02001030 return rc;
1031 }
1032 /* All sub-network service related message types */
1033 rc = gprs_ns2_sns_rx(nsvc, msg, &tp);
1034 break;
1035 case SNS_PDUT_ACK:
1036 case SNS_PDUT_ADD:
1037 case SNS_PDUT_CHANGE_WEIGHT:
1038 case SNS_PDUT_DELETE:
1039 /* weird layout: NSEI TLV, then value-only transaction IE, then TLV again */
Harald Welte36be9d82020-10-09 15:39:25 +02001040 rc = ns2_tlv_parse(&tp, nsh->data+5,
1041 msgb_l2len(msg) - sizeof(*nsh)-5, 0, 0);
Alexander Couzens6a161492020-07-12 13:45:50 +02001042 if (rc < 0) {
Alexander Couzensbb0a53b2020-10-12 04:18:03 +02001043 LOGP(DLNS, LOGL_NOTICE, "Error during TLV Parse in %s\n", msgb_hexdump(msg));
Alexander Couzens6a161492020-07-12 13:45:50 +02001044 return rc;
1045 }
1046 tp.lv[NS_IE_NSEI].val = nsh->data+2;
1047 tp.lv[NS_IE_NSEI].len = 2;
1048 tp.lv[NS_IE_TRANS_ID].val = nsh->data+4;
1049 tp.lv[NS_IE_TRANS_ID].len = 1;
1050 rc = gprs_ns2_sns_rx(nsvc, msg, &tp);
1051 break;
1052 case SNS_PDUT_CONFIG_ACK:
1053 case SNS_PDUT_SIZE:
1054 case SNS_PDUT_SIZE_ACK:
1055 rc = ns2_tlv_parse(&tp, nsh->data,
1056 msgb_l2len(msg) - sizeof(*nsh), 0, 0);
1057 if (rc < 0) {
Alexander Couzensbb0a53b2020-10-12 04:18:03 +02001058 LOGP(DLNS, LOGL_NOTICE, "Error during TLV Parse in %s\n", msgb_hexdump(msg));
Alexander Couzens6a161492020-07-12 13:45:50 +02001059 return rc;
1060 }
1061 /* All sub-network service related message types */
1062 rc = gprs_ns2_sns_rx(nsvc, msg, &tp);
1063 break;
1064
1065 case NS_PDUT_UNITDATA:
1066 rc = gprs_ns2_vc_rx(nsvc, msg, NULL);
1067 break;
1068 default:
1069 rc = ns2_tlv_parse(&tp, nsh->data,
1070 msgb_l2len(msg) - sizeof(*nsh), 0, 0);
1071 if (rc < 0) {
Alexander Couzensbb0a53b2020-10-12 04:18:03 +02001072 LOGP(DLNS, LOGL_NOTICE, "Error during TLV Parse\n");
Alexander Couzens6a161492020-07-12 13:45:50 +02001073 if (nsh->pdu_type != NS_PDUT_STATUS)
1074 ns2_tx_status(nsvc, NS_CAUSE_PROTO_ERR_UNSPEC, 0, msg);
1075 return rc;
1076 }
1077 rc = gprs_ns2_vc_rx(nsvc, msg, &tp);
1078 break;
1079 }
1080
1081 return rc;
1082}
1083
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +01001084/* summarize all active data nsvcs */
1085void ns2_nse_data_sum(struct gprs_ns2_nse *nse)
1086{
1087 struct gprs_ns2_vc *nsvc;
Alexander Couzens8a2a1a42020-12-26 18:00:17 +01001088 nse->nsvc_count = 0;
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +01001089
1090 llist_for_each_entry(nsvc, &nse->nsvc, list) {
1091 if (!gprs_ns2_vc_is_unblocked(nsvc))
1092 continue;
Alexander Couzens8a2a1a42020-12-26 18:00:17 +01001093
1094 nse->nsvc_count++;
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +01001095 }
1096}
1097
Harald Welte5bef2cc2020-09-18 22:33:24 +02001098/*! Notify a nse about the change of a NS-VC.
1099 * \param[in] nsvc NS-VC which has detected the change (and shall not be notified).
1100 * \param[in] unblocked whether the NSE should be marked as unblocked (true) or blocked (false) */
Alexander Couzens6a161492020-07-12 13:45:50 +02001101void ns2_nse_notify_unblocked(struct gprs_ns2_vc *nsvc, bool unblocked)
1102{
1103 struct gprs_ns2_nse *nse = nsvc->nse;
1104 struct gprs_ns2_vc *tmp;
1105
Alexander Couzensfc3dd1f2020-11-19 00:41:47 +01001106 ns2_nse_data_sum(nse);
1107
Alexander Couzens6a161492020-07-12 13:45:50 +02001108 if (unblocked == nse->alive)
1109 return;
1110
1111 if (unblocked) {
1112 /* this is the first unblocked NSVC on an unavailable NSE */
1113 nse->alive = true;
Daniel Willmann15c09a82020-11-03 23:05:43 +01001114 ns2_prim_status_ind(nse, NULL, 0, NS_AFF_CAUSE_RECOVERY);
Alexander Couzensda0a2852020-10-01 23:24:07 +02001115 nse->first = false;
Alexander Couzens6a161492020-07-12 13:45:50 +02001116 return;
1117 }
1118
1119 /* check if there are any remaining alive vcs */
1120 llist_for_each_entry(tmp, &nse->nsvc, list) {
1121 if (tmp == nsvc)
1122 continue;
1123
1124 if (gprs_ns2_vc_is_unblocked(tmp)) {
1125 /* there is at least one remaining alive NSVC */
1126 return;
1127 }
1128 }
1129
1130 /* nse became unavailable */
1131 nse->alive = false;
Daniel Willmann15c09a82020-11-03 23:05:43 +01001132 ns2_prim_status_ind(nse, NULL, 0, NS_AFF_CAUSE_FAILURE);
Alexander Couzens6a161492020-07-12 13:45:50 +02001133}
1134
1135/*! Create a new GPRS NS instance
Harald Welte5bef2cc2020-09-18 22:33:24 +02001136 * \param[in] ctx a talloc context to allocate NS instance from
Alexander Couzenscce88282020-10-26 00:25:50 +01001137 * \param[in] cb Call-back function for dispatching primitives to the user. The Call-back must free all msgb* given in the primitive.
Harald Welte5bef2cc2020-09-18 22:33:24 +02001138 * \param[in] cb_data transparent user data passed to Call-back
1139 * \returns dynamically allocated gprs_ns_inst; NULL on error */
Alexander Couzens6a161492020-07-12 13:45:50 +02001140struct gprs_ns2_inst *gprs_ns2_instantiate(void *ctx, osmo_prim_cb cb, void *cb_data)
1141{
1142 struct gprs_ns2_inst *nsi;
1143
1144 nsi = talloc_zero(ctx, struct gprs_ns2_inst);
1145 if (!nsi)
1146 return NULL;
1147
1148 nsi->cb = cb;
1149 nsi->cb_data = cb_data;
1150 INIT_LLIST_HEAD(&nsi->binding);
1151 INIT_LLIST_HEAD(&nsi->nse);
1152
1153 nsi->timeout[NS_TOUT_TNS_BLOCK] = 3;
1154 nsi->timeout[NS_TOUT_TNS_BLOCK_RETRIES] = 3;
1155 nsi->timeout[NS_TOUT_TNS_RESET] = 3;
1156 nsi->timeout[NS_TOUT_TNS_RESET_RETRIES] = 3;
1157 nsi->timeout[NS_TOUT_TNS_TEST] = 30;
1158 nsi->timeout[NS_TOUT_TNS_ALIVE] = 3;
1159 nsi->timeout[NS_TOUT_TNS_ALIVE_RETRIES] = 10;
1160 nsi->timeout[NS_TOUT_TSNS_PROV] = 3; /* 1..10 */
Alexander Couzens90ee9632020-12-07 06:18:32 +01001161 nsi->timeout[NS_TOUT_TSNS_SIZE_RETRIES] = 3;
1162 nsi->timeout[NS_TOUT_TSNS_CONFIG_RETRIES] = 3;
Alexander Couzens6a161492020-07-12 13:45:50 +02001163
1164 return nsi;
1165}
1166
Harald Welte5bef2cc2020-09-18 22:33:24 +02001167/*! Destroy a NS Instance (including all its NSEs, binds, ...).
1168 * \param[in] nsi NS instance to destroy */
Alexander Couzens6a161492020-07-12 13:45:50 +02001169void gprs_ns2_free(struct gprs_ns2_inst *nsi)
1170{
Alexander Couzens6a161492020-07-12 13:45:50 +02001171 if (!nsi)
1172 return;
1173
Alexander Couzens4b6c8af2020-10-11 20:15:25 +02001174 gprs_ns2_free_nses(nsi);
Alexander Couzens896fcd52020-10-11 19:52:36 +02001175 gprs_ns2_free_binds(nsi);
Alexander Couzens35315042020-10-10 03:28:17 +02001176
1177 talloc_free(nsi);
Alexander Couzens6a161492020-07-12 13:45:50 +02001178}
1179
Harald Welte5bef2cc2020-09-18 22:33:24 +02001180/*! Configure whether a NS Instance should dynamically create NSEs based on incoming traffic.
1181 * \param nsi the instance to modify
1182 * \param create_nse if NSE can be created on receiving package. SGSN set this.
1183 * \return 0 on success; negative on error
Alexander Couzens6a161492020-07-12 13:45:50 +02001184 */
1185int gprs_ns2_dynamic_create_nse(struct gprs_ns2_inst *nsi, bool create_nse)
1186{
1187 nsi->create_nse = create_nse;
1188
1189 return 0;
1190}
1191
Harald Welte5bef2cc2020-09-18 22:33:24 +02001192/*! Start the NS-ALIVE FSM in all NS-VCs of given NSE.
1193 * \param[in] nse NS Entity in whihc to start NS-ALIVE FSMs */
Alexander Couzens6a161492020-07-12 13:45:50 +02001194void gprs_ns2_start_alive_all_nsvcs(struct gprs_ns2_nse *nse)
1195{
1196 struct gprs_ns2_vc *nsvc;
1197 OSMO_ASSERT(nse);
1198
1199 llist_for_each_entry(nsvc, &nse->nsvc, list) {
1200 if (nsvc->sns_only)
1201 continue;
1202
1203 gprs_ns2_vc_fsm_start(nsvc);
1204 }
1205}
1206
Harald Welte5bef2cc2020-09-18 22:33:24 +02001207/*! Destroy a given bind.
1208 * \param[in] bind the bind we want to destroy */
Alexander Couzens6a161492020-07-12 13:45:50 +02001209void gprs_ns2_free_bind(struct gprs_ns2_vc_bind *bind)
1210{
1211 struct gprs_ns2_vc *nsvc, *tmp;
1212 if (!bind)
1213 return;
1214
1215 llist_for_each_entry_safe(nsvc, tmp, &bind->nsvc, blist) {
1216 gprs_ns2_free_nsvc(nsvc);
1217 }
1218
1219 if (bind->driver->free_bind)
1220 bind->driver->free_bind(bind);
1221
1222 llist_del(&bind->list);
Alexander Couzensaaa55a62020-12-03 06:02:03 +01001223 talloc_free((char *)bind->name);
Alexander Couzens6a161492020-07-12 13:45:50 +02001224 talloc_free(bind);
1225}
Alexander Couzens896fcd52020-10-11 19:52:36 +02001226
1227void gprs_ns2_free_binds(struct gprs_ns2_inst *nsi)
1228{
1229 struct gprs_ns2_vc_bind *bind, *tbind;
1230
1231 llist_for_each_entry_safe(bind, tbind, &nsi->binding, list) {
1232 gprs_ns2_free_bind(bind);
1233 }
1234}
Alexander Couzensd923cff2020-12-01 01:03:52 +01001235
Alexander Couzensaaa55a62020-12-03 06:02:03 +01001236/*! Search for a bind with a unique name
1237 * \param[in] nsi NS instance on which we operate
1238 * \param[in] name The unique bind name to search for
1239 * \return the bind or NULL if not found
1240 */
1241struct gprs_ns2_vc_bind *gprs_ns2_bind_by_name(
1242 struct gprs_ns2_inst *nsi, const char *name)
1243{
1244 struct gprs_ns2_vc_bind *bind;
1245
1246 llist_for_each_entry(bind, &nsi->binding, list) {
1247 if (!strcmp(bind->name, name))
1248 return bind;
1249 }
1250
1251 return NULL;
1252}
1253
Alexander Couzensd923cff2020-12-01 01:03:52 +01001254enum gprs_ns2_vc_mode gprs_ns2_dialect_to_vc_mode(
1255 enum gprs_ns2_dialect dialect)
1256{
1257 switch (dialect) {
1258 case NS2_DIALECT_SNS:
1259 case NS2_DIALECT_STATIC_ALIVE:
1260 return NS2_VC_MODE_ALIVE;
1261 case NS2_DIALECT_STATIC_RESETBLOCK:
1262 case NS2_DIALECT_IPACCESS:
1263 return NS2_VC_MODE_BLOCKRESET;
1264 default:
1265 return -1;
1266 }
1267}
1268
Alexander Couzens1c8785d2020-12-17 06:58:53 +01001269static void add_bind_array(struct gprs_ns2_vc_bind **array,
1270 struct gprs_ns2_vc_bind *bind, int size)
1271{
1272 int i;
1273 for (i=0; i < size; i++) {
1274 if (array[i] == bind)
1275 return;
1276 if (!array[i])
1277 break;
1278 }
1279
1280 if (i == size)
1281 return;
1282
1283 array[i] = bind;
1284}
1285
1286/*! calculate the transfer capabilities for a nse
1287 * \param nse the nse to count the transfer capability
1288 * \param bvci a bvci - unused
1289 * \return the transfer capability in mbit. On error < 0.
1290 */
1291int ns2_count_transfer_cap(struct gprs_ns2_nse *nse,
1292 uint16_t bvci)
1293{
1294 struct gprs_ns2_vc *nsvc;
1295 struct gprs_ns2_vc_bind **active_binds;
1296 int i, active_nsvcs = 0, transfer_cap = 0;
1297
1298 /* calculate the transfer capabilities based on the binds.
1299 * A bind has a transfer capability which is shared across all NSVCs.
1300 * Take care the bind cap is not counted twice within a NSE.
1301 * This should be accurate for FR and UDP but not for FR/GRE. */
1302
1303 if (!nse->alive)
1304 return 0;
1305
1306 llist_for_each_entry(nsvc, &nse->nsvc, list) {
1307 if (gprs_ns2_vc_is_unblocked(nsvc))
1308 active_nsvcs++;
1309 }
1310 /* an alive nse should always have active_nsvcs */
1311 OSMO_ASSERT(active_nsvcs);
1312
1313 active_binds = talloc_zero_array(nse, struct gprs_ns2_vc_bind*, active_nsvcs);
1314 if (!active_binds)
1315 return -ENOMEM;
1316
1317 llist_for_each_entry(nsvc, &nse->nsvc, list) {
1318 if (!gprs_ns2_vc_is_unblocked(nsvc))
1319 continue;
1320 add_bind_array(active_binds, nsvc->bind, active_nsvcs);
1321 }
1322
1323 /* TODO: change calcuation for FR/GRE */
1324 for (i = 0; i < active_nsvcs; i++) {
1325 if (active_binds[i])
1326 transfer_cap += active_binds[i]->transfer_capability;
1327 }
1328
1329 talloc_free(active_binds);
1330 return transfer_cap;
1331}
1332
Alexander Couzens6a161492020-07-12 13:45:50 +02001333/*! @} */