blob: acf37a28b0df428f2972dca425f82f2911a2ca80 [file] [log] [blame]
Harald Welte9b455bf2010-03-14 15:45:01 +08001/* GPRS SGSN functionality */
2
3/* (C) 2009 by Harald Welte <laforge@gnumonks.org>
4 *
5 * All Rights Reserved
6 *
7 * This program is free software; you can redistribute it and/or modify
Harald Welte9af6ddf2011-01-01 15:25:50 +01008 * it under the terms of the GNU Affero General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
Harald Welte9b455bf2010-03-14 15:45:01 +080010 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Harald Welte9af6ddf2011-01-01 15:25:50 +010015 * GNU Affero General Public License for more details.
Harald Welte9b455bf2010-03-14 15:45:01 +080016 *
Harald Welte9af6ddf2011-01-01 15:25:50 +010017 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
Harald Welte9b455bf2010-03-14 15:45:01 +080019 *
20 */
21
Harald Welteeaa614c2010-05-02 11:26:34 +020022#include <stdint.h>
Harald Welte9b455bf2010-03-14 15:45:01 +080023
Pablo Neira Ayuso136f4532011-03-22 16:47:59 +010024#include <osmocom/core/linuxlist.h>
25#include <osmocom/core/talloc.h>
26#include <osmocom/core/timer.h>
27#include <osmocom/core/rate_ctr.h>
Harald Weltefdf453c2012-07-14 12:15:19 +020028#include <osmocom/core/backtrace.h>
Harald Welteea34a4e2012-06-16 14:59:56 +080029#include <osmocom/gprs/gprs_ns.h>
30#include <osmocom/gprs/gprs_bssgp.h>
31
Harald Welte9b455bf2010-03-14 15:45:01 +080032#include <openbsc/gsm_subscriber.h>
Harald Weltecb991632010-04-26 19:18:54 +020033#include <openbsc/debug.h>
Harald Welte9b455bf2010-03-14 15:45:01 +080034#include <openbsc/gprs_sgsn.h>
Harald Welteab1d5622010-05-18 19:58:38 +020035#include <openbsc/sgsn.h>
Harald Weltea9b473a2010-12-24 21:13:26 +010036#include <openbsc/gsm_04_08_gprs.h>
37#include <openbsc/gprs_gmm.h>
Jacob Erlbeck99985b52014-10-13 10:32:00 +020038#include "openbsc/gprs_llc.h"
Harald Welteab1d5622010-05-18 19:58:38 +020039
Jacob Erlbeck81ffb742015-01-23 11:33:51 +010040#include <time.h>
41
42#define GPRS_LLME_CHECK_TICK 30
43
Harald Welteab1d5622010-05-18 19:58:38 +020044extern struct sgsn_instance *sgsn;
Harald Welte9b455bf2010-03-14 15:45:01 +080045
Harald Welted193cb32010-05-17 22:58:03 +020046LLIST_HEAD(sgsn_mm_ctxts);
47LLIST_HEAD(sgsn_ggsn_ctxts);
48LLIST_HEAD(sgsn_apn_ctxts);
49LLIST_HEAD(sgsn_pdp_ctxts);
Harald Welte9b455bf2010-03-14 15:45:01 +080050
Harald Welte8acd88f2010-05-18 10:57:45 +020051static const struct rate_ctr_desc mmctx_ctr_description[] = {
52 { "sign.packets.in", "Signalling Messages ( In)" },
53 { "sign.packets.out", "Signalling Messages (Out)" },
54 { "udata.packets.in", "User Data Messages ( In)" },
55 { "udata.packets.out", "User Data Messages (Out)" },
56 { "udata.bytes.in", "User Data Bytes ( In)" },
57 { "udata.bytes.out", "User Data Bytes (Out)" },
58 { "pdp_ctx_act", "PDP Context Activations " },
59 { "suspend", "SUSPEND Count " },
60 { "paging.ps", "Paging Packet Switched " },
61 { "paging.cs", "Paging Circuit Switched " },
62 { "ra_update", "Routing Area Update " },
63};
64
65static const struct rate_ctr_group_desc mmctx_ctrg_desc = {
66 .group_name_prefix = "sgsn.mmctx",
67 .group_description = "SGSN MM Context Statistics",
68 .num_ctr = ARRAY_SIZE(mmctx_ctr_description),
69 .ctr_desc = mmctx_ctr_description,
70};
71
Harald Welteefbdee92010-06-10 00:20:12 +020072static const struct rate_ctr_desc pdpctx_ctr_description[] = {
73 { "udata.packets.in", "User Data Messages ( In)" },
74 { "udata.packets.out", "User Data Messages (Out)" },
75 { "udata.bytes.in", "User Data Bytes ( In)" },
76 { "udata.bytes.out", "User Data Bytes (Out)" },
77};
78
79static const struct rate_ctr_group_desc pdpctx_ctrg_desc = {
80 .group_name_prefix = "sgsn.pdpctx",
81 .group_description = "SGSN PDP Context Statistics",
82 .num_ctr = ARRAY_SIZE(pdpctx_ctr_description),
83 .ctr_desc = pdpctx_ctr_description,
84};
85
Harald Welte9b455bf2010-03-14 15:45:01 +080086static int ra_id_equals(const struct gprs_ra_id *id1,
87 const struct gprs_ra_id *id2)
88{
89 return (id1->mcc == id2->mcc && id1->mnc == id2->mnc &&
90 id1->lac == id2->lac && id1->rac == id2->rac);
91}
92
Harald Weltef6bd3402010-12-23 23:34:43 +010093/* See 03.02 Chapter 2.6 */
94static inline uint32_t tlli_foreign(uint32_t tlli)
95{
96 return ((tlli | 0x80000000) & ~0x40000000);
97}
98
Harald Welte9b455bf2010-03-14 15:45:01 +080099/* look-up a SGSN MM context based on TLLI + RAI */
Harald Welteeaa614c2010-05-02 11:26:34 +0200100struct sgsn_mm_ctx *sgsn_mm_ctx_by_tlli(uint32_t tlli,
Harald Welte9b455bf2010-03-14 15:45:01 +0800101 const struct gprs_ra_id *raid)
102{
103 struct sgsn_mm_ctx *ctx;
Harald Welteab1d5622010-05-18 19:58:38 +0200104 int tlli_type;
Harald Welte9b455bf2010-03-14 15:45:01 +0800105
106 llist_for_each_entry(ctx, &sgsn_mm_ctxts, list) {
107 if (tlli == ctx->tlli &&
108 ra_id_equals(raid, &ctx->ra))
109 return ctx;
110 }
Harald Welteab1d5622010-05-18 19:58:38 +0200111
112 tlli_type = gprs_tlli_type(tlli);
Harald Weltef6bd3402010-12-23 23:34:43 +0100113 switch (tlli_type) {
114 case TLLI_LOCAL:
Harald Welteab1d5622010-05-18 19:58:38 +0200115 llist_for_each_entry(ctx, &sgsn_mm_ctxts, list) {
Harald Weltec2e8cc42010-05-31 20:23:38 +0200116 if ((ctx->p_tmsi | 0xC0000000) == tlli ||
117 (ctx->p_tmsi_old && (ctx->p_tmsi_old | 0xC0000000) == tlli)) {
Harald Welteab1d5622010-05-18 19:58:38 +0200118 ctx->tlli = tlli;
119 return ctx;
120 }
121 }
Harald Weltef6bd3402010-12-23 23:34:43 +0100122 break;
123 case TLLI_FOREIGN:
124 llist_for_each_entry(ctx, &sgsn_mm_ctxts, list) {
125 if (tlli == tlli_foreign(ctx->tlli) &&
126 ra_id_equals(raid, &ctx->ra))
127 return ctx;
128 }
129 break;
130 default:
131 break;
Harald Welteab1d5622010-05-18 19:58:38 +0200132 }
133
Harald Welte9b455bf2010-03-14 15:45:01 +0800134 return NULL;
135}
136
Harald Welteeaa614c2010-05-02 11:26:34 +0200137struct sgsn_mm_ctx *sgsn_mm_ctx_by_ptmsi(uint32_t p_tmsi)
Harald Welte9b455bf2010-03-14 15:45:01 +0800138{
139 struct sgsn_mm_ctx *ctx;
140
141 llist_for_each_entry(ctx, &sgsn_mm_ctxts, list) {
Harald Weltec2e8cc42010-05-31 20:23:38 +0200142 if (p_tmsi == ctx->p_tmsi ||
143 (ctx->p_tmsi_old && ctx->p_tmsi_old == p_tmsi))
Harald Welte9b455bf2010-03-14 15:45:01 +0800144 return ctx;
145 }
146 return NULL;
147}
148
149struct sgsn_mm_ctx *sgsn_mm_ctx_by_imsi(const char *imsi)
150{
151 struct sgsn_mm_ctx *ctx;
152
153 llist_for_each_entry(ctx, &sgsn_mm_ctxts, list) {
154 if (!strcmp(imsi, ctx->imsi))
155 return ctx;
156 }
157 return NULL;
158
159}
160
161/* Allocate a new SGSN MM context */
Harald Welteeaa614c2010-05-02 11:26:34 +0200162struct sgsn_mm_ctx *sgsn_mm_ctx_alloc(uint32_t tlli,
Harald Welte9b455bf2010-03-14 15:45:01 +0800163 const struct gprs_ra_id *raid)
164{
Harald Welte2720e732010-05-17 00:44:57 +0200165 struct sgsn_mm_ctx *ctx;
Harald Welte9b455bf2010-03-14 15:45:01 +0800166
Harald Welte2720e732010-05-17 00:44:57 +0200167 ctx = talloc_zero(tall_bsc_ctx, struct sgsn_mm_ctx);
Harald Welte9b455bf2010-03-14 15:45:01 +0800168 if (!ctx)
169 return NULL;
170
171 memcpy(&ctx->ra, raid, sizeof(ctx->ra));
172 ctx->tlli = tlli;
173 ctx->mm_state = GMM_DEREGISTERED;
Jacob Erlbeckbd0cf112014-12-01 12:33:33 +0100174 ctx->auth_triplet.key_seq = GSM_KEY_SEQ_INVAL;
Harald Welte8acd88f2010-05-18 10:57:45 +0200175 ctx->ctrg = rate_ctr_group_alloc(ctx, &mmctx_ctrg_desc, tlli);
Harald Welte6ffbaab2010-05-18 12:44:45 +0200176 INIT_LLIST_HEAD(&ctx->pdp_list);
Harald Welte9b455bf2010-03-14 15:45:01 +0800177
178 llist_add(&ctx->list, &sgsn_mm_ctxts);
179
180 return ctx;
181}
Harald Welted193cb32010-05-17 22:58:03 +0200182
Harald Welte7b022ee2012-07-14 12:04:04 +0200183/* this is a hard _free_ function, it doesn't clean up the PDP contexts
184 * in libgtp! */
Harald Weltec728eea2010-12-24 23:07:18 +0100185void sgsn_mm_ctx_free(struct sgsn_mm_ctx *mm)
186{
187 struct sgsn_pdp_ctx *pdp, *pdp2;
188
Jacob Erlbeckae20b4b2014-10-20 16:05:55 +0200189 if (osmo_timer_pending(&mm->timer)) {
190 LOGMMCTXP(LOGL_INFO, mm, "Cancelling MM timer %u\n", mm->T);
191 osmo_timer_del(&mm->timer);
192 }
193
Holger Hans Peter Freythere47d4f62015-01-20 21:14:03 +0100194 /* Unlink from global list of MM contexts */
195 llist_del(&mm->list);
196
Jacob Erlbeckbe2c8d92014-11-12 10:18:09 +0100197 /* Detach from subscriber which is possibly freed then */
198 if (mm->subscr) {
199 struct gsm_subscriber *subscr = mm->subscr;
200 mm->subscr = NULL;
Jacob Erlbecka1e03732014-12-02 11:28:38 +0100201 subscr->sgsn_data->mm = NULL;
Jacob Erlbeckbe2c8d92014-11-12 10:18:09 +0100202 gprs_subscr_delete(subscr);
203 }
204
Harald Weltec728eea2010-12-24 23:07:18 +0100205 /* Free all PDP contexts */
206 llist_for_each_entry_safe(pdp, pdp2, &mm->pdp_list, list)
207 sgsn_pdp_ctx_free(pdp);
208
209 rate_ctr_group_free(mm->ctrg);
210
211 talloc_free(mm);
212}
Harald Welte77289c22010-05-18 14:32:29 +0200213
Harald Welte96df6062010-06-03 06:37:26 +0200214/* look up PDP context by MM context and NSAPI */
Harald Welted193cb32010-05-17 22:58:03 +0200215struct sgsn_pdp_ctx *sgsn_pdp_ctx_by_nsapi(const struct sgsn_mm_ctx *mm,
216 uint8_t nsapi)
217{
218 struct sgsn_pdp_ctx *pdp;
219
220 llist_for_each_entry(pdp, &mm->pdp_list, list) {
221 if (pdp->nsapi == nsapi)
222 return pdp;
223 }
224 return NULL;
225}
226
Harald Welte96df6062010-06-03 06:37:26 +0200227/* look up PDP context by MM context and transaction ID */
Harald Welte77289c22010-05-18 14:32:29 +0200228struct sgsn_pdp_ctx *sgsn_pdp_ctx_by_tid(const struct sgsn_mm_ctx *mm,
229 uint8_t tid)
230{
231 struct sgsn_pdp_ctx *pdp;
232
233 llist_for_each_entry(pdp, &mm->pdp_list, list) {
234 if (pdp->ti == tid)
235 return pdp;
236 }
237 return NULL;
238}
239
Harald Welte7b022ee2012-07-14 12:04:04 +0200240/* you don't want to use this directly, call sgsn_create_pdp_ctx() */
Harald Welted193cb32010-05-17 22:58:03 +0200241struct sgsn_pdp_ctx *sgsn_pdp_ctx_alloc(struct sgsn_mm_ctx *mm,
242 uint8_t nsapi)
243{
244 struct sgsn_pdp_ctx *pdp;
245
246 pdp = sgsn_pdp_ctx_by_nsapi(mm, nsapi);
247 if (pdp)
248 return NULL;
249
250 pdp = talloc_zero(tall_bsc_ctx, struct sgsn_pdp_ctx);
251 if (!pdp)
252 return NULL;
253
254 pdp->mm = mm;
255 pdp->nsapi = nsapi;
Harald Welteefbdee92010-06-10 00:20:12 +0200256 pdp->ctrg = rate_ctr_group_alloc(pdp, &pdpctx_ctrg_desc, nsapi);
Harald Welted193cb32010-05-17 22:58:03 +0200257 llist_add(&pdp->list, &mm->pdp_list);
258 llist_add(&pdp->g_list, &sgsn_pdp_ctxts);
259
260 return pdp;
261}
262
Harald Weltefdf453c2012-07-14 12:15:19 +0200263#include <pdp.h>
Jacob Erlbeck99985b52014-10-13 10:32:00 +0200264/*
265 * This function will not trigger any GSM DEACT PDP ACK messages, so you
266 * probably want to call sgsn_delete_pdp_ctx() instead if the connection
267 * isn't detached already.
268 */
269void sgsn_pdp_ctx_terminate(struct sgsn_pdp_ctx *pdp)
270{
271 OSMO_ASSERT(pdp->mm != NULL);
272
273 /* There might still be pending callbacks in libgtp. So the parts of
274 * this object relevant to GTP need to remain intact in this case. */
275
276 LOGPDPCTXP(LOGL_INFO, pdp, "Forcing release of PDP context\n");
277
278 /* Force the deactivation of the SNDCP layer */
279 sndcp_sm_deactivate_ind(&pdp->mm->llme->lle[pdp->sapi], pdp->nsapi);
280
281 /* Detach from MM context */
282 llist_del(&pdp->list);
283 pdp->mm = NULL;
284
285 sgsn_delete_pdp_ctx(pdp);
286}
287
288/*
289 * Don't call this function directly unless you know what you are doing.
290 * In normal conditions use sgsn_delete_pdp_ctx and in unspecified or
291 * implementation dependent abnormal ones sgsn_pdp_ctx_terminate.
292 */
Harald Welted193cb32010-05-17 22:58:03 +0200293void sgsn_pdp_ctx_free(struct sgsn_pdp_ctx *pdp)
294{
Harald Welte376d5e52010-06-28 18:57:21 +0200295 rate_ctr_group_free(pdp->ctrg);
Jacob Erlbeck99985b52014-10-13 10:32:00 +0200296 if (pdp->mm)
297 llist_del(&pdp->list);
Harald Welted193cb32010-05-17 22:58:03 +0200298 llist_del(&pdp->g_list);
Harald Weltefdf453c2012-07-14 12:15:19 +0200299
300 /* _if_ we still have a library handle, at least set it to NULL
301 * to avoid any dereferences of the now-deleted PDP context from
302 * sgsn_libgtp:cb_data_ind() */
303 if (pdp->lib) {
304 struct pdp_t *lib = pdp->lib;
Daniel Willmann46553142014-09-03 17:46:44 +0200305 LOGPDPCTXP(LOGL_NOTICE, pdp, "freeing PDP context that still "
Harald Weltefdf453c2012-07-14 12:15:19 +0200306 "has a libgtp handle attached to it, this shouldn't "
307 "happen!\n");
308 osmo_generate_backtrace();
309 lib->priv = NULL;
310 }
311
Harald Welted193cb32010-05-17 22:58:03 +0200312 talloc_free(pdp);
313}
314
315/* GGSN contexts */
316
Harald Welte77289c22010-05-18 14:32:29 +0200317struct sgsn_ggsn_ctx *sgsn_ggsn_ctx_alloc(uint32_t id)
Harald Welted193cb32010-05-17 22:58:03 +0200318{
Harald Welte77289c22010-05-18 14:32:29 +0200319 struct sgsn_ggsn_ctx *ggc;
Harald Welted193cb32010-05-17 22:58:03 +0200320
Harald Welte77289c22010-05-18 14:32:29 +0200321 ggc = talloc_zero(tall_bsc_ctx, struct sgsn_ggsn_ctx);
Harald Welted193cb32010-05-17 22:58:03 +0200322 if (!ggc)
323 return NULL;
324
325 ggc->id = id;
326 ggc->gtp_version = 1;
Harald Weltea9b473a2010-12-24 21:13:26 +0100327 ggc->remote_restart_ctr = -1;
Harald Welteab1d5622010-05-18 19:58:38 +0200328 /* if we are called from config file parse, this gsn doesn't exist yet */
329 ggc->gsn = sgsn->gsn;
Harald Welte119c2ba2010-05-18 18:39:00 +0200330 llist_add(&ggc->list, &sgsn_ggsn_ctxts);
Harald Welted193cb32010-05-17 22:58:03 +0200331
332 return ggc;
333}
334
Harald Welte77289c22010-05-18 14:32:29 +0200335struct sgsn_ggsn_ctx *sgsn_ggsn_ctx_by_id(uint32_t id)
Harald Welted193cb32010-05-17 22:58:03 +0200336{
Harald Welte77289c22010-05-18 14:32:29 +0200337 struct sgsn_ggsn_ctx *ggc;
Harald Welted193cb32010-05-17 22:58:03 +0200338
339 llist_for_each_entry(ggc, &sgsn_ggsn_ctxts, list) {
340 if (id == ggc->id)
341 return ggc;
342 }
343 return NULL;
344}
345
Harald Weltea9b473a2010-12-24 21:13:26 +0100346struct sgsn_ggsn_ctx *sgsn_ggsn_ctx_by_addr(struct in_addr *addr)
347{
348 struct sgsn_ggsn_ctx *ggc;
349
350 llist_for_each_entry(ggc, &sgsn_ggsn_ctxts, list) {
351 if (!memcmp(addr, &ggc->remote_addr, sizeof(*addr)))
352 return ggc;
353 }
354 return NULL;
355}
356
357
Harald Welte77289c22010-05-18 14:32:29 +0200358struct sgsn_ggsn_ctx *sgsn_ggsn_ctx_find_alloc(uint32_t id)
Harald Welted193cb32010-05-17 22:58:03 +0200359{
Harald Welte77289c22010-05-18 14:32:29 +0200360 struct sgsn_ggsn_ctx *ggc;
Harald Welted193cb32010-05-17 22:58:03 +0200361
Harald Welte77289c22010-05-18 14:32:29 +0200362 ggc = sgsn_ggsn_ctx_by_id(id);
Harald Welted193cb32010-05-17 22:58:03 +0200363 if (!ggc)
Harald Welte77289c22010-05-18 14:32:29 +0200364 ggc = sgsn_ggsn_ctx_alloc(id);
Harald Welted193cb32010-05-17 22:58:03 +0200365 return ggc;
366}
367
368/* APN contexts */
369
370#if 0
371struct apn_ctx *apn_ctx_alloc(const char *ap_name)
372{
373 struct apn_ctx *actx;
374
375 actx = talloc_zero(talloc_bsc_ctx, struct apn_ctx);
376 if (!actx)
377 return NULL;
378 actx->name = talloc_strdup(actx, ap_name);
379
380 return actx;
381}
382
383struct apn_ctx *apn_ctx_by_name(const char *name)
384{
385 struct apn_ctx *actx;
386
387 llist_for_each_entry(actx, &sgsn_apn_ctxts, list) {
388 if (!strcmp(name, actx->name))
389 return actx;
390 }
391 return NULL;
392}
393
394struct apn_ctx *apn_ctx_find_alloc(const char *name)
395{
396 struct apn_ctx *actx;
397
398 actx = apn_ctx_by_name(name);
399 if (!actx)
400 actx = apn_ctx_alloc(name);
401
402 return actx;
403}
404#endif
Harald Welte6463c072010-05-18 17:04:55 +0200405
406uint32_t sgsn_alloc_ptmsi(void)
407{
408 struct sgsn_mm_ctx *mm;
409 uint32_t ptmsi;
Jacob Erlbeckd8a65532015-01-15 18:51:31 +0100410 int max_retries = 100;
Harald Welte6463c072010-05-18 17:04:55 +0200411
412restart:
Jacob Erlbeckd8a65532015-01-15 18:51:31 +0100413 ptmsi = rand();
414 /* Enforce that the 2 MSB are set without loosing the distance between
415 * identical values. Since rand() has no duplicate values within a
416 * period (because the size of the state is the same like the size of
417 * the random value), this leads to a distance of period/4 when the
418 * distribution of the 2 MSB is uniform. This approach fails with a
419 * probability of (3/4)^max_retries, only 1% of the approaches will
420 * need more than 16 numbers (even distribution assumed).
421 *
422 * Alternatively, a freeze list could be used if another PRNG is used
423 * or when this approach proves to be not sufficient.
424 */
425 if (ptmsi >= 0xC0000000) {
426 if (!max_retries--)
427 goto failed;
428 goto restart;
429 }
430 ptmsi |= 0xC0000000;
431
432 if (ptmsi == GSM_RESERVED_TMSI) {
433 if (!max_retries--)
434 goto failed;
435 goto restart;
436 }
437
Harald Welte6463c072010-05-18 17:04:55 +0200438 llist_for_each_entry(mm, &sgsn_mm_ctxts, list) {
Jacob Erlbeck08fbeb82014-09-19 09:28:42 +0200439 if (mm->p_tmsi == ptmsi) {
440 if (!max_retries--)
441 goto failed;
Harald Welte6463c072010-05-18 17:04:55 +0200442 goto restart;
Jacob Erlbeck08fbeb82014-09-19 09:28:42 +0200443 }
Harald Welte6463c072010-05-18 17:04:55 +0200444 }
445
446 return ptmsi;
Jacob Erlbeck08fbeb82014-09-19 09:28:42 +0200447
448failed:
449 LOGP(DGPRS, LOGL_ERROR, "Failed to allocate a P-TMSI\n");
450 return GSM_RESERVED_TMSI;
Harald Welte6463c072010-05-18 17:04:55 +0200451}
Harald Weltea9b473a2010-12-24 21:13:26 +0100452
453static void drop_one_pdp(struct sgsn_pdp_ctx *pdp)
454{
455 if (pdp->mm->mm_state == GMM_REGISTERED_NORMAL)
456 gsm48_tx_gsm_deact_pdp_req(pdp, GSM_CAUSE_NET_FAIL);
457 else {
458 /* FIXME: GPRS paging in case MS is SUSPENDED */
Daniel Willmann46553142014-09-03 17:46:44 +0200459 LOGPDPCTXP(LOGL_NOTICE, pdp, "Hard-dropping PDP ctx due to GGSN "
Harald Weltea9b473a2010-12-24 21:13:26 +0100460 "recovery\n");
Harald Welte7b022ee2012-07-14 12:04:04 +0200461 /* FIXME: how to tell this to libgtp? */
Harald Weltea9b473a2010-12-24 21:13:26 +0100462 sgsn_pdp_ctx_free(pdp);
463 }
464}
465
466/* High-level function to be called in case a GGSN has disappeared or
Holger Hans Peter Freyther19e990d2014-10-27 10:24:37 +0100467 * otherwise lost state (recovery procedure) */
Harald Weltea9b473a2010-12-24 21:13:26 +0100468int drop_all_pdp_for_ggsn(struct sgsn_ggsn_ctx *ggsn)
469{
470 struct sgsn_mm_ctx *mm;
471 int num = 0;
472
473 llist_for_each_entry(mm, &sgsn_mm_ctxts, list) {
474 struct sgsn_pdp_ctx *pdp;
475 llist_for_each_entry(pdp, &mm->pdp_list, list) {
476 if (pdp->ggsn == ggsn) {
477 drop_one_pdp(pdp);
478 num++;
479 }
480 }
481 }
482
483 return num;
484}
Jacob Erlbeck78ecaf02014-09-05 14:32:36 +0200485
486int sgsn_force_reattach_oldmsg(struct msgb *oldmsg)
487{
Jacob Erlbeckabdf02b2014-10-31 12:20:49 +0100488 return gsm0408_gprs_force_reattach_oldmsg(oldmsg);
Jacob Erlbeck78ecaf02014-09-05 14:32:36 +0200489}
490
Jacob Erlbeck33b6dad2014-11-12 10:12:11 +0100491void sgsn_update_subscriber_data(struct sgsn_mm_ctx *mmctx,
492 struct gsm_subscriber *subscr)
Jacob Erlbeck423f8bf2014-10-24 18:09:54 +0200493{
Jacob Erlbeckbe2c8d92014-11-12 10:18:09 +0100494 if (!mmctx && subscr && strlen(subscr->imsi) > 0) {
495 mmctx = sgsn_mm_ctx_by_imsi(subscr->imsi);
496 OSMO_ASSERT(!mmctx || !mmctx->subscr || mmctx->subscr == subscr);
497 }
498
499 if (!mmctx) {
500 LOGP(DMM, LOGL_INFO,
501 "Subscriber data update for unregistered MM context, IMSI %s\n",
502 subscr->imsi);
503 return;
504 }
505
Jacob Erlbeckc9391962014-12-18 09:53:07 +0100506 LOGMMCTXP(LOGL_INFO, mmctx, "Subscriber data update\n");
Jacob Erlbeckbe2c8d92014-11-12 10:18:09 +0100507
Jacob Erlbecka1e03732014-12-02 11:28:38 +0100508 if (!subscr->sgsn_data->mm && !mmctx->subscr) {
Jacob Erlbeckbe2c8d92014-11-12 10:18:09 +0100509 mmctx->subscr = subscr_get(subscr);
Jacob Erlbecka1e03732014-12-02 11:28:38 +0100510 mmctx->subscr->sgsn_data->mm = mmctx;
Jacob Erlbeckbe2c8d92014-11-12 10:18:09 +0100511 }
Jacob Erlbeck423f8bf2014-10-24 18:09:54 +0200512
Jacob Erlbecka0b6efb2014-11-13 10:48:39 +0100513 sgsn_auth_update(mmctx);
Jacob Erlbeck423f8bf2014-10-24 18:09:54 +0200514}
Jacob Erlbeck81ffb742015-01-23 11:33:51 +0100515
516static void sgsn_llme_cleanup_free(struct gprs_llc_llme *llme)
517{
518 struct sgsn_mm_ctx *mmctx = NULL;
519
520 llist_for_each_entry(mmctx, &sgsn_mm_ctxts, list) {
521 if (llme == mmctx->llme) {
522 gsm0408_gprs_access_cancelled(mmctx, SGSN_ERROR_CAUSE_NONE);
523 return;
524 }
525 }
526
527 /* No MM context found */
528 LOGP(DGPRS, LOGL_INFO, "Deleting orphaned LLME, TLLI 0x%08x\n",
529 llme->tlli);
530 gprs_llgmm_assign(llme, llme->tlli, 0xffffffff, GPRS_ALGO_GEA0, NULL);
531}
532
533static void sgsn_llme_check_cb(void *data_)
534{
535 struct gprs_llc_llme *llme, *llme_tmp;
536 struct timespec now_tp;
537 time_t now, age;
538 time_t max_age = gprs_max_time_to_idle();
539
540 int rc;
541
542 rc = clock_gettime(CLOCK_MONOTONIC, &now_tp);
543 OSMO_ASSERT(rc >= 0);
544 now = now_tp.tv_sec;
545
546 LOGP(DGPRS, LOGL_DEBUG,
547 "Checking for inactive LLMEs, time = %u\n", (unsigned)now);
548
549 llist_for_each_entry_safe(llme, llme_tmp, &gprs_llc_llmes, list) {
550 if (llme->age_timestamp == GPRS_LLME_RESET_AGE)
551 llme->age_timestamp = now;
552
553 age = now - llme->age_timestamp;
554
555 if (age > max_age || age < 0) {
556 LOGP(DGPRS, LOGL_INFO,
557 "Inactivity timeout for TLLI 0x%08x, age %d\n",
558 llme->tlli, (int)age);
559 sgsn_llme_cleanup_free(llme);
560 }
561 }
562
563 osmo_timer_schedule(&sgsn->llme_timer, GPRS_LLME_CHECK_TICK, 0);
564}
565
566void sgsn_inst_init()
567{
568 sgsn->llme_timer.cb = sgsn_llme_check_cb;
569 sgsn->llme_timer.data = NULL;
570
571 osmo_timer_schedule(&sgsn->llme_timer, GPRS_LLME_CHECK_TICK, 0);
572}
573