Coverage Report

Created: 2023-11-19 06:47

/src/open5gs/lib/app/ogs-context.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
3
 *
4
 * This file is part of Open5GS.
5
 *
6
 * This program is free software: you can redistribute it and/or modify
7
 * it under the terms of the GNU Affero General Public License as published by
8
 * the Free Software Foundation, either version 3 of the License, or
9
 * (at your option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
18
 */
19
20
#include "ogs-app.h"
21
22
static ogs_app_context_t self;
23
24
static int initialized = 0;
25
26
static void app_context_prepare(void);
27
28
int ogs_app_context_init(void)
29
0
{
30
0
    ogs_assert(initialized == 0);
31
32
0
    memset(&self, 0, sizeof(ogs_app_context_t));
33
34
0
    app_context_prepare();
35
36
0
    initialized = 1;
37
38
0
    return OGS_OK;
39
0
}
40
41
void ogs_app_context_final(void)
42
0
{
43
0
    ogs_assert(initialized == 1);
44
45
0
    if (self.document) {
46
0
        yaml_document_delete(self.document);
47
0
        free(self.document);
48
0
    }
49
50
0
    if (self.pollset)
51
0
        ogs_pollset_destroy(self.pollset);
52
0
    if (self.timer_mgr)
53
0
        ogs_timer_mgr_destroy(self.timer_mgr);
54
0
    if (self.queue)
55
0
        ogs_queue_destroy(self.queue);
56
57
0
    initialized = 0;
58
0
}
59
60
ogs_app_context_t *ogs_app(void)
61
0
{
62
0
    return &self;
63
0
}
64
65
static void recalculate_pool_size(void)
66
0
{
67
0
    self.pool.packet = self.max.ue * OGS_MAX_NUM_OF_PACKET_BUFFER;
68
69
0
#define MAX_NUM_OF_TUNNEL       3   /* Num of Tunnel per Bearer */
70
0
    self.pool.sess = self.max.ue * OGS_MAX_NUM_OF_SESS;
71
0
    self.pool.bearer = self.pool.sess * OGS_MAX_NUM_OF_BEARER;
72
0
    self.pool.tunnel = self.pool.bearer * MAX_NUM_OF_TUNNEL;
73
74
0
#define POOL_NUM_PER_UE 16
75
0
    self.pool.timer = self.max.ue * POOL_NUM_PER_UE;
76
0
    self.pool.message = self.max.ue * POOL_NUM_PER_UE;
77
0
    self.pool.event = self.max.ue * POOL_NUM_PER_UE;
78
0
    self.pool.socket = self.max.ue * POOL_NUM_PER_UE;
79
0
    self.pool.xact = self.max.ue * POOL_NUM_PER_UE;
80
0
    self.pool.stream = self.max.ue * POOL_NUM_PER_UE;
81
82
0
    self.pool.nf = self.max.peer;
83
0
#define NF_SERVICE_PER_NF_INSTANCE 16
84
0
    self.pool.nf_service = self.pool.nf * NF_SERVICE_PER_NF_INSTANCE;
85
0
    self.pool.subscription = self.pool.nf * NF_SERVICE_PER_NF_INSTANCE;
86
87
0
    self.pool.gtp_node = self.pool.nf;
88
0
    if (self.max.gtp_peer)
89
0
        self.pool.gtp_node = self.max.gtp_peer;
90
91
    /* Num of TAI-LAI Mapping Table */
92
0
    self.pool.csmap = self.pool.nf;
93
94
0
#define MAX_NUM_OF_IMPU         8
95
0
    self.pool.impi = self.max.ue;
96
0
    self.pool.impu = self.pool.impi * MAX_NUM_OF_IMPU;
97
0
}
98
99
static void regenerate_all_timer_duration(void)
100
0
{
101
0
    ogs_assert(self.time.message.duration);
102
103
0
    self.time.message.sbi.client_wait_duration = self.time.message.duration;
104
0
    self.time.message.sbi.connection_deadline =
105
0
        self.time.message.sbi.client_wait_duration + ogs_time_from_sec(1);
106
0
    self.time.message.sbi.nf_register_interval =
107
0
        ogs_max(ogs_time_from_sec(3),
108
0
            self.time.message.sbi.client_wait_duration + ogs_time_from_sec(1));
109
0
    self.time.message.sbi.nf_register_interval_in_exception =
110
0
                ogs_time_from_sec(2);
111
112
0
#define PFCP_N1_RESPONSE_RETRY_COUNT  3
113
0
    self.time.message.pfcp.n1_response_rcount = PFCP_N1_RESPONSE_RETRY_COUNT;
114
0
    self.time.message.pfcp.t1_response_duration =
115
0
        (self.time.message.duration /
116
0
         (self.time.message.pfcp.n1_response_rcount + 1));
117
0
    ogs_assert(self.time.message.pfcp.t1_response_duration);
118
119
0
#define PFCP_N1_HOLDING_RETRY_COUNT 1
120
0
    self.time.message.pfcp.n1_holding_rcount = PFCP_N1_HOLDING_RETRY_COUNT;
121
0
    self.time.message.pfcp.t1_holding_duration =
122
0
        self.time.message.pfcp.n1_response_rcount *
123
0
        self.time.message.pfcp.t1_response_duration;
124
0
    ogs_assert(self.time.message.pfcp.t1_holding_duration);
125
126
0
    self.time.message.pfcp.association_interval =
127
0
        ogs_max(ogs_time_from_sec(3),
128
0
            self.time.message.sbi.client_wait_duration + ogs_time_from_sec(1));
129
130
0
    self.time.message.pfcp.no_heartbeat_duration =
131
0
        ogs_max(ogs_time_from_sec(10),
132
0
            self.time.message.sbi.client_wait_duration + ogs_time_from_sec(1));
133
134
0
#define GTP_N3_RESPONSE_RETRY_COUNT  3
135
0
    self.time.message.gtp.n3_response_rcount = GTP_N3_RESPONSE_RETRY_COUNT;
136
0
    self.time.message.gtp.t3_response_duration =
137
0
        (self.time.message.duration /
138
0
         (self.time.message.gtp.n3_response_rcount + 1));
139
0
    ogs_assert(self.time.message.gtp.t3_response_duration);
140
141
0
#define GTP_N3_HOLDING_RETRY_COUNT 1
142
0
    self.time.message.gtp.n3_holding_rcount = GTP_N3_HOLDING_RETRY_COUNT;
143
0
    self.time.message.gtp.t3_holding_duration =
144
0
        self.time.message.gtp.n3_response_rcount *
145
0
        self.time.message.gtp.t3_response_duration;
146
0
    ogs_assert(self.time.message.gtp.t3_holding_duration);
147
148
#if 0
149
    ogs_trace("%lld, %lld, %lld, %d, %lld, %d %lld, %d, %lld, %d, %lld",
150
        (long long)self.time.message.duration,
151
        (long long)self.time.message.sbi.client_wait_duration,
152
        (long long)self.time.message.sbi.connection_deadline,
153
        self.time.message.pfcp.n1_response_rcount,
154
        (long long)self.time.message.pfcp.t1_response_duration,
155
        self.time.message.pfcp.n1_holding_rcount,
156
        (long long)self.time.message.pfcp.t1_holding_duration,
157
        self.time.message.gtp.n3_response_rcount,
158
        (long long)self.time.message.gtp.t3_response_duration,
159
        self.time.message.gtp.n3_holding_rcount,
160
        (long long)self.time.message.gtp.t3_holding_duration);
161
    ogs_trace("%lld, %lld, %lld",
162
        (long long)self.time.message.sbi.nf_register_interval,
163
        (long long)self.time.message.pfcp.association_interval,
164
        (long long)self.time.message.pfcp.no_heartbeat_duration);
165
#endif
166
0
}
167
168
static void app_context_prepare(void)
169
0
{
170
0
#define USRSCTP_LOCAL_UDP_PORT      9899
171
0
    self.usrsctp.udp_port = USRSCTP_LOCAL_UDP_PORT;
172
173
0
    self.sockopt.no_delay = true;
174
175
0
#define MAX_NUM_OF_UE               1024    /* Num of UEs */
176
0
#define MAX_NUM_OF_PEER             64      /* Num of Peer */
177
178
0
    self.max.ue = MAX_NUM_OF_UE;
179
0
    self.max.peer = MAX_NUM_OF_PEER;
180
181
0
    ogs_pkbuf_default_init(&self.pool.defconfig);
182
183
0
    recalculate_pool_size();
184
185
    /* <Heartbeat Checking Interval>
186
     *  Heartbeat Interval(e.g: 10 seconds) + No Heartbeat Margin(1 second) */
187
0
    self.time.nf_instance.no_heartbeat_margin = 1;
188
189
    /* 3600 seconds = 1 hour */
190
0
    self.time.nf_instance.validity_duration = 3600;
191
192
    /* 86400 seconds = 1 day */
193
0
    self.time.subscription.validity_duration = 86400;
194
195
    /*
196
     * Message Wait Duration : 10 seconds (Default)
197
     *
198
     * The paging retry timer is 2 seconds and the retry count is 3.
199
     *
200
     * It is recomended to set at least 9 seconds to reflect
201
     * the paging failure result to GTPv2-C or HTTP2(SBI).
202
     */
203
0
    self.time.message.duration = ogs_time_from_sec(10);
204
205
    /*
206
     * Handover Wait Duration : 300 ms (Default)
207
     *
208
     * Time to wait for AMF/MME to send UEContextReleaseCommand
209
     * to the source gNB/eNB after receiving HandoverNotify
210
     */
211
0
    self.time.handover.duration = ogs_time_from_msec(300);
212
213
    /* Size of internal metrics pool (amount of ogs_metrics_spec_t) */
214
0
    self.metrics.max_specs = 512;
215
216
0
    regenerate_all_timer_duration();
217
0
}
218
219
static int app_context_validation(void)
220
0
{
221
0
    if (self.parameter.no_ipv4 == 1 &&
222
0
        self.parameter.no_ipv6 == 1) {
223
0
        ogs_error("Both `no_ipv4` and `no_ipv6` set to `true` in `%s`",
224
0
                self.file);
225
0
        return OGS_ERROR;
226
0
    }
227
228
0
    if (self.time.nf_instance.validity_duration == 0) {
229
0
        ogs_error("NF Instance validity-time should not 0");
230
0
        ogs_error("time:");
231
0
        ogs_error("  nf_instance:");
232
0
        ogs_error("    validity: 0");
233
234
0
        return OGS_ERROR;
235
0
    }
236
237
0
    return OGS_OK;
238
0
}
239
240
int ogs_app_context_parse_config(void)
241
0
{
242
0
    int rv;
243
0
    yaml_document_t *document = NULL;
244
0
    ogs_yaml_iter_t root_iter;
245
246
0
    document = self.document;
247
0
    ogs_assert(document);
248
249
0
    ogs_yaml_iter_init(&root_iter, document);
250
0
    while (ogs_yaml_iter_next(&root_iter)) {
251
0
        const char *root_key = ogs_yaml_iter_key(&root_iter);
252
0
        ogs_assert(root_key);
253
0
        if (!strcmp(root_key, "db_uri")) {
254
0
            self.db_uri = ogs_yaml_iter_value(&root_iter);
255
0
        } else if (!strcmp(root_key, "logger")) {
256
0
            ogs_yaml_iter_t logger_iter;
257
0
            ogs_yaml_iter_recurse(&root_iter, &logger_iter);
258
0
            while (ogs_yaml_iter_next(&logger_iter)) {
259
0
                const char *logger_key = ogs_yaml_iter_key(&logger_iter);
260
0
                ogs_assert(logger_key);
261
0
                if (!strcmp(logger_key, "file")) {
262
0
                    self.logger.file = ogs_yaml_iter_value(&logger_iter);
263
0
                } else if (!strcmp(logger_key, "level")) {
264
0
                    self.logger.level =
265
0
                        ogs_yaml_iter_value(&logger_iter);
266
0
                } else if (!strcmp(logger_key, "domain")) {
267
0
                    self.logger.domain =
268
0
                        ogs_yaml_iter_value(&logger_iter);
269
0
                }
270
0
            }
271
0
        } else if (!strcmp(root_key, "parameter")) {
272
0
            ogs_yaml_iter_t parameter_iter;
273
0
            ogs_yaml_iter_recurse(&root_iter, &parameter_iter);
274
0
            while (ogs_yaml_iter_next(&parameter_iter)) {
275
0
                const char *parameter_key = ogs_yaml_iter_key(&parameter_iter);
276
0
                ogs_assert(parameter_key);
277
0
                if (!strcmp(parameter_key, "no_hss")) {
278
0
                    self.parameter.no_hss =
279
0
                        ogs_yaml_iter_bool(&parameter_iter);
280
0
                } else if (!strcmp(parameter_key, "no_mme")) {
281
0
                    self.parameter.no_mme =
282
0
                        ogs_yaml_iter_bool(&parameter_iter);
283
0
                } else if (!strcmp(parameter_key, "no_sgwu")) {
284
0
                    self.parameter.no_sgwu =
285
0
                        ogs_yaml_iter_bool(&parameter_iter);
286
0
                } else if (!strcmp(parameter_key, "no_sgwc")) {
287
0
                    self.parameter.no_sgwc =
288
0
                        ogs_yaml_iter_bool(&parameter_iter);
289
0
                } else if (!strcmp(parameter_key, "no_sgw")) {
290
0
                    self.parameter.no_sgw =
291
0
                        ogs_yaml_iter_bool(&parameter_iter);
292
0
                } else if (!strcmp(parameter_key, "no_pgw")) {
293
0
                    self.parameter.no_pgw =
294
0
                        ogs_yaml_iter_bool(&parameter_iter);
295
0
                } else if (!strcmp(parameter_key, "no_pcrf")) {
296
0
                    self.parameter.no_pcrf =
297
0
                        ogs_yaml_iter_bool(&parameter_iter);
298
0
                } else if (!strcmp(parameter_key, "no_nrf")) {
299
0
                    self.parameter.no_nrf =
300
0
                        ogs_yaml_iter_bool(&parameter_iter);
301
0
                } else if (!strcmp(parameter_key, "no_scp")) {
302
0
                    self.parameter.no_scp =
303
0
                        ogs_yaml_iter_bool(&parameter_iter);
304
0
                } else if (!strcmp(parameter_key, "no_amf")) {
305
0
                    self.parameter.no_amf =
306
0
                        ogs_yaml_iter_bool(&parameter_iter);
307
0
                } else if (!strcmp(parameter_key, "no_smf")) {
308
0
                    self.parameter.no_smf =
309
0
                        ogs_yaml_iter_bool(&parameter_iter);
310
0
                } else if (!strcmp(parameter_key, "no_upf")) {
311
0
                    self.parameter.no_upf =
312
0
                        ogs_yaml_iter_bool(&parameter_iter);
313
0
                } else if (!strcmp(parameter_key, "no_ausf")) {
314
0
                    self.parameter.no_ausf =
315
0
                        ogs_yaml_iter_bool(&parameter_iter);
316
0
                } else if (!strcmp(parameter_key, "no_udm")) {
317
0
                    self.parameter.no_udm =
318
0
                        ogs_yaml_iter_bool(&parameter_iter);
319
0
                } else if (!strcmp(parameter_key, "no_pcf")) {
320
0
                    self.parameter.no_pcf =
321
0
                        ogs_yaml_iter_bool(&parameter_iter);
322
0
                } else if (!strcmp(parameter_key, "no_nssf")) {
323
0
                    self.parameter.no_nssf =
324
0
                        ogs_yaml_iter_bool(&parameter_iter);
325
0
                } else if (!strcmp(parameter_key, "no_bsf")) {
326
0
                    self.parameter.no_bsf =
327
0
                        ogs_yaml_iter_bool(&parameter_iter);
328
0
                } else if (!strcmp(parameter_key, "no_udr")) {
329
0
                    self.parameter.no_udr =
330
0
                        ogs_yaml_iter_bool(&parameter_iter);
331
0
                } else if (!strcmp(parameter_key, "no_ipv4")) {
332
0
                    self.parameter.no_ipv4 =
333
0
                        ogs_yaml_iter_bool(&parameter_iter);
334
0
                } else if (!strcmp(parameter_key, "no_ipv6")) {
335
0
                    self.parameter.no_ipv6 =
336
0
                        ogs_yaml_iter_bool(&parameter_iter);
337
0
                } else if (!strcmp(parameter_key, "prefer_ipv4")) {
338
0
                    self.parameter.prefer_ipv4 =
339
0
                        ogs_yaml_iter_bool(&parameter_iter);
340
0
                } else if (!strcmp(parameter_key, "multicast")) {
341
0
                    self.parameter.multicast =
342
0
                        ogs_yaml_iter_bool(&parameter_iter);
343
0
                } else if (!strcmp(parameter_key, "use_openair")) {
344
0
                    self.parameter.use_openair =
345
0
                        ogs_yaml_iter_bool(&parameter_iter);
346
0
                } else if (!strcmp(
347
0
                    parameter_key, "no_ipv4v6_local_addr_in_packet_filter")) {
348
0
                    self.parameter.no_ipv4v6_local_addr_in_packet_filter =
349
0
                        ogs_yaml_iter_bool(&parameter_iter);
350
0
                } else if (!strcmp(parameter_key, "no_pfcp_rr_select")) {
351
0
                    self.parameter.no_pfcp_rr_select =
352
0
                        ogs_yaml_iter_bool(&parameter_iter);
353
0
                } else if (!strcmp(parameter_key,
354
0
                            "use_mongodb_change_stream")) {
355
0
                    self.use_mongodb_change_stream = 
356
0
                        ogs_yaml_iter_bool(&parameter_iter);
357
0
                } else
358
0
                    ogs_warn("unknown key `%s`", parameter_key);
359
0
            }
360
0
        } else if (!strcmp(root_key, "sockopt")) {
361
0
            ogs_yaml_iter_t sockopt_iter;
362
0
            ogs_yaml_iter_recurse(&root_iter, &sockopt_iter);
363
0
            while (ogs_yaml_iter_next(&sockopt_iter)) {
364
0
                const char *sockopt_key = ogs_yaml_iter_key(&sockopt_iter);
365
0
                ogs_assert(sockopt_key);
366
0
                if (!strcmp(sockopt_key, "no_delay")) {
367
0
                    self.sockopt.no_delay =
368
0
                        ogs_yaml_iter_bool(&sockopt_iter);
369
0
                } else if (!strcmp(sockopt_key, "linger")) {
370
0
                    const char *v = ogs_yaml_iter_value(&sockopt_iter);
371
0
                    if (v) self.sockopt.l_linger = atoi(v);
372
0
                    self.sockopt.l_onoff = true;
373
0
                } else
374
0
                    ogs_warn("unknown key `%s`", sockopt_key);
375
0
            }
376
0
        } else if (!strcmp(root_key, "max")) {
377
0
            ogs_yaml_iter_t max_iter;
378
0
            ogs_yaml_iter_recurse(&root_iter, &max_iter);
379
0
            while (ogs_yaml_iter_next(&max_iter)) {
380
0
                const char *max_key = ogs_yaml_iter_key(&max_iter);
381
0
                ogs_assert(max_key);
382
0
                if (!strcmp(max_key, "ue")) {
383
0
                    const char *v = ogs_yaml_iter_value(&max_iter);
384
0
                    if (v) self.max.ue = atoi(v);
385
0
                } else if (!strcmp(max_key, "peer") ||
386
0
                            !strcmp(max_key, "enb")) {
387
0
                    const char *v = ogs_yaml_iter_value(&max_iter);
388
0
                    if (v) self.max.peer = atoi(v);
389
0
                } else if (!strcmp(max_key, "gtp_peer") ||
390
0
                            !strcmp(max_key, "enb")) {
391
0
                    const char *v = ogs_yaml_iter_value(&max_iter);
392
0
                    if (v) self.max.gtp_peer = atoi(v);
393
0
                } else
394
0
                    ogs_warn("unknown key `%s`", max_key);
395
0
            }
396
397
0
            recalculate_pool_size();
398
0
        } else if (!strcmp(root_key, "pool")) {
399
0
            ogs_yaml_iter_t pool_iter;
400
0
            ogs_yaml_iter_recurse(&root_iter, &pool_iter);
401
0
            while (ogs_yaml_iter_next(&pool_iter)) {
402
0
                const char *pool_key = ogs_yaml_iter_key(&pool_iter);
403
0
                ogs_assert(pool_key);
404
0
                if (!strcmp(pool_key, "128")) {
405
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
406
0
                    if (v)
407
0
                        self.pool.defconfig.cluster_128_pool = atoi(v);
408
0
                } else if (!strcmp(pool_key, "256")) {
409
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
410
0
                    if (v)
411
0
                        self.pool.defconfig.cluster_256_pool = atoi(v);
412
0
                } else if (!strcmp(pool_key, "512")) {
413
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
414
0
                    if (v)
415
0
                        self.pool.defconfig.cluster_512_pool = atoi(v);
416
0
                } else if (!strcmp(pool_key, "1024")) {
417
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
418
0
                    if (v)
419
0
                        self.pool.defconfig.cluster_1024_pool = atoi(v);
420
0
                } else if (!strcmp(pool_key, "2048")) {
421
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
422
0
                    if (v)
423
0
                        self.pool.defconfig.cluster_2048_pool = atoi(v);
424
0
                } else if (!strcmp(pool_key, "8192")) {
425
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
426
0
                    if (v)
427
0
                        self.pool.defconfig.cluster_8192_pool = atoi(v);
428
0
                } else if (!strcmp(pool_key, "32768")) {
429
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
430
0
                    if (v)
431
0
                        self.pool.defconfig.cluster_32768_pool = atoi(v);
432
0
                } else if (!strcmp(pool_key, "big")) {
433
0
                    const char *v = ogs_yaml_iter_value(&pool_iter);
434
0
                    if (v)
435
0
                        self.pool.defconfig.cluster_big_pool = atoi(v);
436
0
                } else
437
0
                    ogs_warn("unknown key `%s`", pool_key);
438
0
            }
439
0
        } else if (!strcmp(root_key, "time")) {
440
0
            ogs_yaml_iter_t time_iter;
441
0
            ogs_yaml_iter_recurse(&root_iter, &time_iter);
442
0
            while (ogs_yaml_iter_next(&time_iter)) {
443
0
                const char *time_key = ogs_yaml_iter_key(&time_iter);
444
0
                ogs_assert(time_key);
445
0
                if (!strcmp(time_key, "nf_instance")) {
446
0
                    ogs_yaml_iter_t sbi_iter;
447
0
                    ogs_yaml_iter_recurse(&time_iter, &sbi_iter);
448
449
0
                    while (ogs_yaml_iter_next(&sbi_iter)) {
450
0
                        const char *sbi_key =
451
0
                            ogs_yaml_iter_key(&sbi_iter);
452
0
                        ogs_assert(sbi_key);
453
454
0
                        if (!strcmp(sbi_key, "heartbeat")) {
455
0
                            const char *v = ogs_yaml_iter_value(&sbi_iter);
456
0
                            if (v) self.time.nf_instance.heartbeat_interval =
457
0
                                        atoi(v);
458
0
                        } else if (!strcmp(sbi_key, "validity")) {
459
0
                            const char *v = ogs_yaml_iter_value(&sbi_iter);
460
0
                            if (v) self.time.nf_instance.validity_duration =
461
0
                                        atoi(v);
462
0
                        } else
463
0
                            ogs_warn("unknown key `%s`", sbi_key);
464
0
                    }
465
0
                } else if (!strcmp(time_key, "subscription")) {
466
0
                    ogs_yaml_iter_t sbi_iter;
467
0
                    ogs_yaml_iter_recurse(&time_iter, &sbi_iter);
468
469
0
                    while (ogs_yaml_iter_next(&sbi_iter)) {
470
0
                        const char *sbi_key =
471
0
                            ogs_yaml_iter_key(&sbi_iter);
472
0
                        ogs_assert(sbi_key);
473
474
0
                        if (!strcmp(sbi_key, "validity")) {
475
0
                            const char *v = ogs_yaml_iter_value(&sbi_iter);
476
0
                            if (v) self.time.subscription.validity_duration =
477
0
                                        atoi(v);
478
0
                        } else
479
0
                            ogs_warn("unknown key `%s`", sbi_key);
480
0
                    }
481
0
                } else if (!strcmp(time_key, "message")) {
482
0
                    ogs_yaml_iter_t msg_iter;
483
0
                    ogs_yaml_iter_recurse(&time_iter, &msg_iter);
484
485
0
                    while (ogs_yaml_iter_next(&msg_iter)) {
486
0
                        const char *msg_key =
487
0
                            ogs_yaml_iter_key(&msg_iter);
488
0
                        ogs_assert(msg_key);
489
490
0
                        if (!strcmp(msg_key, "duration")) {
491
0
                            const char *v = ogs_yaml_iter_value(&msg_iter);
492
0
                            if (v) {
493
0
                                self.time.message.duration =
494
0
                                    ogs_time_from_msec(atoll(v));
495
0
                                regenerate_all_timer_duration();
496
0
                            }
497
0
                        } else
498
0
                            ogs_warn("unknown key `%s`", msg_key);
499
0
                    }
500
0
                } else if (!strcmp(time_key, "handover")) {
501
0
                    ogs_yaml_iter_t msg_iter;
502
0
                    ogs_yaml_iter_recurse(&time_iter, &msg_iter);
503
504
0
                    while (ogs_yaml_iter_next(&msg_iter)) {
505
0
                        const char *msg_key =
506
0
                            ogs_yaml_iter_key(&msg_iter);
507
0
                        ogs_assert(msg_key);
508
509
0
                        if (!strcmp(msg_key, "duration")) {
510
0
                            const char *v = ogs_yaml_iter_value(&msg_iter);
511
0
                            if (v) {
512
0
                                self.time.handover.duration =
513
0
                                    ogs_time_from_msec(atoll(v));
514
0
                            }
515
0
                        } else
516
0
                            ogs_warn("unknown key `%s`", msg_key);
517
0
                    }
518
0
                } else if (!strcmp(time_key, "t3502")) {
519
                    /* handle config in amf */
520
0
                } else if (!strcmp(time_key, "t3512")) {
521
                    /* handle config in amf */
522
0
                } else if (!strcmp(time_key, "t3402")) {
523
                    /* handle config in mme */
524
0
                } else if (!strcmp(time_key, "t3412")) {
525
                    /* handle config in mme */
526
0
                } else if (!strcmp(time_key, "t3423")) {
527
                    /* handle config in mme */
528
0
                } else
529
0
                    ogs_warn("unknown key `%s`", time_key);
530
0
            }
531
0
        } else if (!strcmp(root_key, "sbi")) {
532
0
            ogs_yaml_iter_t tls_iter;
533
0
            ogs_yaml_iter_recurse(&root_iter, &tls_iter);
534
0
            while (ogs_yaml_iter_next(&tls_iter)) {
535
0
                const char *tls_key = ogs_yaml_iter_key(&tls_iter);
536
0
                ogs_assert(tls_key);
537
0
                if (!strcmp(tls_key, "server")) {
538
0
                    ogs_yaml_iter_t server_iter;
539
0
                    ogs_yaml_iter_recurse(&tls_iter, &server_iter);
540
541
0
                    while (ogs_yaml_iter_next(&server_iter)) {
542
0
                        const char *server_key =
543
0
                            ogs_yaml_iter_key(&server_iter);
544
0
                        ogs_assert(server_key);
545
0
                        if (!strcmp(server_key, "no_tls")) {
546
0
                            self.sbi.server.no_tls =
547
0
                                ogs_yaml_iter_bool(&server_iter);
548
0
                        } else if (!strcmp(server_key, "no_verify")) {
549
0
                            self.sbi.server.no_verify =
550
0
                                ogs_yaml_iter_bool(&server_iter);
551
0
                        } else if (!strcmp(server_key, "cacert")) {
552
0
                            self.sbi.server.cacert =
553
0
                                ogs_yaml_iter_value(&server_iter);
554
0
                        } else if (!strcmp(server_key, "cert")) {
555
0
                            self.sbi.server.cert =
556
0
                                ogs_yaml_iter_value(&server_iter);
557
0
                        } else if (!strcmp(server_key, "key")) {
558
0
                            self.sbi.server.key =
559
0
                                ogs_yaml_iter_value(&server_iter);
560
0
                        } else
561
0
                            ogs_warn("unknown key `%s`", server_key);
562
0
                    }
563
0
                } else if (!strcmp(tls_key, "client")) {
564
0
                    ogs_yaml_iter_t client_iter;
565
0
                    ogs_yaml_iter_recurse(&tls_iter, &client_iter);
566
567
0
                    while (ogs_yaml_iter_next(&client_iter)) {
568
0
                        const char *client_key =
569
0
                            ogs_yaml_iter_key(&client_iter);
570
0
                        ogs_assert(client_key);
571
0
                        if (!strcmp(client_key, "no_tls")) {
572
0
                            self.sbi.client.no_tls =
573
0
                                ogs_yaml_iter_bool(&client_iter);
574
0
                        } else if (!strcmp(client_key, "no_verify")) {
575
0
                            self.sbi.client.no_verify =
576
0
                                ogs_yaml_iter_bool(&client_iter);
577
0
                        } else if (!strcmp(client_key, "cacert")) {
578
0
                            self.sbi.client.cacert =
579
0
                                ogs_yaml_iter_value(&client_iter);
580
0
                        } else if (!strcmp(client_key, "cert")) {
581
0
                            self.sbi.client.cert =
582
0
                                ogs_yaml_iter_value(&client_iter);
583
0
                        } else if (!strcmp(client_key, "key")) {
584
0
                            self.sbi.client.key =
585
0
                                ogs_yaml_iter_value(&client_iter);
586
0
                        } else
587
0
                            ogs_warn("unknown key `%s`", client_key);
588
0
                    }
589
0
                } else
590
0
                    ogs_warn("unknown key `%s`", tls_key);
591
0
            }
592
0
        }
593
0
    }
594
595
0
    rv = app_context_validation();
596
0
    if (rv != OGS_OK) return rv;
597
598
0
    return OGS_OK;
599
0
}