Coverage Report

Created: 2026-07-16 06:07

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/S2OPC/src/ClientServer/services/bgenc/session_mgr.c
Line
Count
Source
1
/*
2
 * Licensed to Systerel under one or more contributor license
3
 * agreements. See the NOTICE file distributed with this work
4
 * for additional information regarding copyright ownership.
5
 * Systerel licenses this file to you under the Apache
6
 * License, Version 2.0 (the "License"); you may not use this
7
 * file except in compliance with the License. You may obtain
8
 * a copy of the License at
9
 *
10
 *   http://www.apache.org/licenses/LICENSE-2.0
11
 *
12
 * Unless required by applicable law or agreed to in writing,
13
 * software distributed under the License is distributed on an
14
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15
 * KIND, either express or implied.  See the License for the
16
 * specific language governing permissions and limitations
17
 * under the License.
18
 */
19
20
/******************************************************************************
21
22
 File Name            : session_mgr.c
23
24
 Date                 : 08/07/2026 11:25:10
25
26
 C Translator Version : tradc Java V1.2 (06/02/2022)
27
28
******************************************************************************/
29
30
/*------------------------
31
   Exported Declarations
32
  ------------------------*/
33
#include "session_mgr.h"
34
35
/*------------------------
36
   INITIALISATION Clause
37
  ------------------------*/
38
0
void session_mgr__INITIALISATION(void) {
39
0
}
40
41
/*--------------------
42
   OPERATIONS Clause
43
  --------------------*/
44
void session_mgr__local_client_remove_all_request_handles(
45
0
   const constants__t_session_i session_mgr__session) {
46
0
   {
47
0
      t_bool session_mgr__l_continue;
48
0
      constants__t_client_request_handle_i session_mgr__l_request_handle;
49
0
      t_bool session_mgr__l_is_valid_req_handle;
50
0
      t_bool session_mgr__l_is_applicative;
51
0
      constants__t_application_context_i session_mgr__l_app_context;
52
0
      constants__t_msg_type_i session_mgr__l_req_typ;
53
      
54
0
      session_request_handle_bs__init_session_req_handle_it(session_mgr__session,
55
0
         &session_mgr__l_continue);
56
0
      if (session_mgr__l_continue == true) {
57
0
         while (session_mgr__l_continue == true) {
58
0
            session_request_handle_bs__continue_and_remove_session_req_handle_it(&session_mgr__l_continue,
59
0
               &session_mgr__l_request_handle);
60
0
            request_handle_bs__is_valid_req_handle(session_mgr__l_request_handle,
61
0
               &session_mgr__l_is_valid_req_handle);
62
0
            if (session_mgr__l_is_valid_req_handle == true) {
63
0
               request_handle_bs__get_req_handle_app_context(session_mgr__l_request_handle,
64
0
                  &session_mgr__l_is_applicative,
65
0
                  &session_mgr__l_app_context);
66
0
               request_handle_bs__get_req_handle_req_typ(session_mgr__l_request_handle,
67
0
                  &session_mgr__l_req_typ);
68
0
               if (session_mgr__l_is_applicative == true) {
69
0
                  service_response_cb_bs__cli_snd_failure(session_mgr__l_req_typ,
70
0
                     session_mgr__l_app_context,
71
0
                     constants_statuscodes_bs__e_sc_bad_session_closed);
72
0
               }
73
0
            }
74
0
         }
75
0
      }
76
0
   }
77
0
}
78
79
void session_mgr__local_client_close_session(
80
   const constants__t_session_i session_mgr__session,
81
0
   const constants_statuscodes_bs__t_StatusCode_i session_mgr__sc_reason) {
82
0
   session_mgr__local_client_remove_all_request_handles(session_mgr__session);
83
0
   session_core__client_close_session_sm(session_mgr__session,
84
0
      session_mgr__sc_reason);
85
0
}
86
87
void session_mgr__local_client_close_session_if_needed(
88
   const t_bool session_mgr__cond,
89
   const constants__t_session_i session_mgr__session,
90
0
   const constants_statuscodes_bs__t_StatusCode_i session_mgr__sc_reason) {
91
0
   if (session_mgr__cond == false) {
92
0
      session_mgr__local_client_close_session(session_mgr__session,
93
0
         session_mgr__sc_reason);
94
0
   }
95
0
}
96
97
void session_mgr__local_client_activate_sessions_on_SC_connection(
98
0
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx) {
99
0
   {
100
0
      t_bool session_mgr__l_continue;
101
0
      constants__t_session_i session_mgr__l_session;
102
0
      t_bool session_mgr__l_dom;
103
0
      constants__t_channel_config_idx_i session_mgr__l_channel_config_idx;
104
      
105
0
      session_mgr_it__init_iter_session(&session_mgr__l_continue);
106
0
      if (session_mgr__l_continue == true) {
107
0
         while (session_mgr__l_continue == true) {
108
0
            session_mgr_it__continue_iter_session(&session_mgr__l_continue,
109
0
               &session_mgr__l_session);
110
0
            session_core__getall_orphaned(session_mgr__l_session,
111
0
               &session_mgr__l_dom,
112
0
               &session_mgr__l_channel_config_idx);
113
0
            if ((session_mgr__l_dom == true) &&
114
0
               (session_mgr__l_channel_config_idx == session_mgr__channel_config_idx)) {
115
0
               session_core__client_gen_activate_orphaned_session_internal_event(session_mgr__l_session,
116
0
                  session_mgr__channel_config_idx);
117
0
            }
118
0
            session_core__getall_to_create(session_mgr__l_session,
119
0
               &session_mgr__l_dom,
120
0
               &session_mgr__l_channel_config_idx);
121
0
            if ((session_mgr__l_dom == true) &&
122
0
               (session_mgr__l_channel_config_idx == session_mgr__channel_config_idx)) {
123
0
               session_core__reset_session_to_create(session_mgr__l_session);
124
0
               session_core__client_gen_create_session_internal_event(session_mgr__l_session,
125
0
                  session_mgr__channel_config_idx);
126
0
            }
127
0
         }
128
0
      }
129
0
   }
130
0
}
131
132
void session_mgr__local_client_close_sessions_on_SC_final_connection_failure(
133
0
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx) {
134
0
   {
135
0
      t_bool session_mgr__l_continue;
136
0
      constants__t_session_i session_mgr__l_session;
137
0
      t_bool session_mgr__l_dom;
138
0
      constants__t_channel_config_idx_i session_mgr__l_channel_config_idx;
139
      
140
0
      session_mgr_it__init_iter_session(&session_mgr__l_continue);
141
0
      if (session_mgr__l_continue == true) {
142
0
         while (session_mgr__l_continue == true) {
143
0
            session_mgr_it__continue_iter_session(&session_mgr__l_continue,
144
0
               &session_mgr__l_session);
145
0
            session_core__getall_orphaned(session_mgr__l_session,
146
0
               &session_mgr__l_dom,
147
0
               &session_mgr__l_channel_config_idx);
148
0
            if ((session_mgr__l_dom == true) &&
149
0
               (session_mgr__l_channel_config_idx == session_mgr__channel_config_idx)) {
150
0
               session_mgr__local_client_close_session(session_mgr__l_session,
151
0
                  constants_statuscodes_bs__e_sc_bad_secure_channel_closed);
152
0
            }
153
0
            session_core__getall_to_create(session_mgr__l_session,
154
0
               &session_mgr__l_dom,
155
0
               &session_mgr__l_channel_config_idx);
156
0
            if ((session_mgr__l_dom == true) &&
157
0
               (session_mgr__l_channel_config_idx == session_mgr__channel_config_idx)) {
158
0
               session_mgr__local_client_close_session(session_mgr__l_session,
159
0
                  constants_statuscodes_bs__e_sc_bad_secure_channel_closed);
160
0
            }
161
0
         }
162
0
      }
163
0
   }
164
0
}
165
166
void session_mgr__local_session_get_endpoint_config(
167
   const constants__t_session_i session_mgr__p_session,
168
0
   constants__t_endpoint_config_idx_i * const session_mgr__endpoint_config_idx) {
169
0
   {
170
0
      constants__t_channel_i session_mgr__l_channel;
171
0
      t_bool session_mgr__l_continue;
172
0
      t_bool session_mgr__l_connected_channel;
173
      
174
0
      *session_mgr__endpoint_config_idx = constants__c_endpoint_config_idx_indet;
175
0
      session_core__getall_valid_session_channel(session_mgr__p_session,
176
0
         &session_mgr__l_continue,
177
0
         &session_mgr__l_channel);
178
0
      if (session_mgr__l_continue == true) {
179
0
         channel_mgr__is_connected_channel(session_mgr__l_channel,
180
0
            &session_mgr__l_connected_channel);
181
0
         if (session_mgr__l_connected_channel == true) {
182
0
            channel_mgr__server_get_endpoint_config(session_mgr__l_channel,
183
0
               session_mgr__endpoint_config_idx);
184
0
         }
185
0
      }
186
0
   }
187
0
}
188
189
void session_mgr__local_client_validate_and_drop_session_req_session_handle(
190
   const constants__t_channel_i session_mgr__channel,
191
   const constants__t_client_request_handle_i session_mgr__req_handle,
192
   t_bool * const session_mgr__bres,
193
0
   constants__t_session_i * const session_mgr__session) {
194
0
   {
195
0
      constants__t_session_i session_mgr__l_session;
196
0
      t_bool session_mgr__l_valid_session;
197
0
      constants__t_sessionState_i session_mgr__l_session_state;
198
0
      constants__t_channel_i session_mgr__l_session_channel;
199
      
200
0
      *session_mgr__session = constants__c_session_indet;
201
0
      session_request_handle_bs__client_get_session_and_remove_request_handle(session_mgr__req_handle,
202
0
         &session_mgr__l_session);
203
0
      session_core__is_valid_session(session_mgr__l_session,
204
0
         &session_mgr__l_valid_session);
205
0
      if (session_mgr__l_valid_session == true) {
206
0
         session_core__get_session_state_or_closed(session_mgr__l_session,
207
0
            &session_mgr__l_session_state);
208
0
         session_core__get_session_channel(session_mgr__l_session,
209
0
            &session_mgr__l_session_channel);
210
0
         if ((session_mgr__l_session_state == constants__e_session_userActivated) &&
211
0
            (session_mgr__l_session_channel == session_mgr__channel)) {
212
0
            session_core__is_session_valid_for_service(session_mgr__channel,
213
0
               session_mgr__l_session,
214
0
               session_mgr__bres);
215
0
         }
216
0
         else {
217
0
            *session_mgr__bres = false;
218
0
         }
219
0
      }
220
0
      else {
221
0
         *session_mgr__bres = false;
222
0
      }
223
0
      if (*session_mgr__bres == true) {
224
0
         *session_mgr__session = session_mgr__l_session;
225
0
      }
226
0
   }
227
0
}
228
229
void session_mgr__client_receive_session_resp(
230
   const constants__t_channel_i session_mgr__channel,
231
   const constants__t_client_request_handle_i session_mgr__req_handle,
232
   const constants__t_msg_type_i session_mgr__resp_typ,
233
   const constants__t_msg_header_i session_mgr__resp_header,
234
   const constants__t_msg_i session_mgr__resp_msg,
235
0
   constants__t_session_i * const session_mgr__session) {
236
0
   {
237
0
      constants__t_session_token_i session_mgr__l_session_token;
238
0
      constants__t_sessionState_i session_mgr__l_session_state;
239
0
      constants__t_channel_i session_mgr__l_session_channel;
240
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_resp_status;
241
0
      constants__t_user_token_i session_mgr__l_session_user_token;
242
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_status_reason;
243
0
      t_bool session_mgr__l_bret;
244
      
245
0
      session_mgr__l_bret = false;
246
0
      session_request_handle_bs__client_get_session_and_remove_request_handle(session_mgr__req_handle,
247
0
         session_mgr__session);
248
0
      session_core__get_session_state_or_closed(*session_mgr__session,
249
0
         &session_mgr__l_session_state);
250
0
      message_in_bs__read_msg_resp_header_service_status(session_mgr__resp_header,
251
0
         &session_mgr__l_resp_status);
252
0
      if ((session_mgr__l_session_state != constants__e_session_closed) &&
253
0
         (session_mgr__l_resp_status == constants_statuscodes_bs__e_sc_ok)) {
254
0
         switch (session_mgr__resp_typ) {
255
0
         case constants__e_msg_session_create_resp:
256
0
            if (session_mgr__l_session_state == constants__e_session_creating) {
257
0
               session_core__get_session_channel(*session_mgr__session,
258
0
                  &session_mgr__l_session_channel);
259
0
               if (session_mgr__l_session_channel == session_mgr__channel) {
260
0
                  message_in_bs__read_create_session_msg_session_token(session_mgr__resp_msg,
261
0
                     &session_mgr__l_session_token);
262
0
                  session_core__client_create_session_resp_sm(session_mgr__channel,
263
0
                     *session_mgr__session,
264
0
                     session_mgr__l_session_token,
265
0
                     session_mgr__resp_msg,
266
0
                     &session_mgr__l_bret);
267
0
                  session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_security_checks_failed;
268
0
                  session_core__get_session_state_or_closed(*session_mgr__session,
269
0
                     &session_mgr__l_session_state);
270
0
                  if (session_mgr__l_session_state == constants__e_session_created) {
271
0
                     session_core__get_session_user_client(*session_mgr__session,
272
0
                        &session_mgr__l_session_user_token);
273
0
                     session_core__client_gen_activate_user_session_internal_event(*session_mgr__session,
274
0
                        session_mgr__l_session_user_token);
275
0
                  }
276
0
                  else {
277
0
                     session_mgr__l_bret = false;
278
0
                  }
279
0
               }
280
0
               else {
281
0
                  session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
282
0
                  ;
283
0
               }
284
0
            }
285
0
            else {
286
0
               session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_invalid_state;
287
0
               ;
288
0
            }
289
0
            break;
290
0
         case constants__e_msg_session_activate_resp:
291
0
            if ((session_mgr__l_session_state == constants__e_session_userActivating) ||
292
0
               (session_mgr__l_session_state == constants__e_session_scActivating)) {
293
0
               session_core__get_session_channel(*session_mgr__session,
294
0
                  &session_mgr__l_session_channel);
295
0
               if (session_mgr__l_session_channel == session_mgr__channel) {
296
0
                  session_core__client_activate_session_resp_sm(session_mgr__channel,
297
0
                     *session_mgr__session,
298
0
                     session_mgr__resp_msg,
299
0
                     &session_mgr__l_bret);
300
0
                  session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_security_checks_failed;
301
0
               }
302
0
               else {
303
0
                  session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
304
0
                  ;
305
0
               }
306
0
            }
307
0
            else {
308
0
               session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_invalid_state;
309
0
               ;
310
0
            }
311
0
            break;
312
0
         case constants__e_msg_session_close_resp:
313
0
            if (session_mgr__l_session_state == constants__e_session_closing) {
314
0
               session_core__get_session_channel(*session_mgr__session,
315
0
                  &session_mgr__l_session_channel);
316
0
               if (session_mgr__l_session_channel == session_mgr__channel) {
317
0
                  session_mgr__local_client_remove_all_request_handles(*session_mgr__session);
318
0
                  session_core__client_close_session_resp_sm(session_mgr__channel,
319
0
                     *session_mgr__session,
320
0
                     session_mgr__resp_msg);
321
0
                  session_mgr__l_bret = true;
322
0
                  session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_ok;
323
0
               }
324
0
               else {
325
0
                  session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
326
0
                  ;
327
0
               }
328
0
            }
329
0
            else {
330
0
               session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_invalid_state;
331
0
               ;
332
0
            }
333
0
            break;
334
0
         case constants__e_msg_session_cancel_resp:
335
0
            session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_service_unsupported;
336
0
            ;
337
0
            break;
338
0
         default:
339
0
            session_mgr__l_status_reason = constants_statuscodes_bs__e_sc_bad_service_unsupported;
340
0
            ;
341
0
            break;
342
0
         }
343
0
         session_mgr__local_client_close_session_if_needed(session_mgr__l_bret,
344
0
            *session_mgr__session,
345
0
            session_mgr__l_status_reason);
346
0
      }
347
0
      else if (session_mgr__l_session_state != constants__e_session_closed) {
348
0
         session_mgr__local_client_close_session(*session_mgr__session,
349
0
            session_mgr__l_resp_status);
350
0
      }
351
0
      else {
352
0
         ;
353
0
      }
354
0
   }
355
0
}
356
357
void session_mgr__client_receive_session_resp_decode_failed(
358
0
   const constants__t_client_request_handle_i session_mgr__req_handle) {
359
0
   {
360
0
      constants__t_session_i session_mgr__l_session;
361
0
      constants__t_sessionState_i session_mgr__l_session_state;
362
      
363
0
      session_request_handle_bs__client_get_session_and_remove_request_handle(session_mgr__req_handle,
364
0
         &session_mgr__l_session);
365
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
366
0
         &session_mgr__l_session_state);
367
0
      if (session_mgr__l_session_state != constants__e_session_closed) {
368
0
         session_mgr__local_client_close_session(session_mgr__l_session,
369
0
            constants_statuscodes_bs__e_sc_bad_decoding_error);
370
0
      }
371
0
      else {
372
0
         ;
373
0
      }
374
0
   }
375
0
}
376
377
void session_mgr__server_receive_session_req(
378
   const constants__t_channel_i session_mgr__channel,
379
   const constants__t_session_token_i session_mgr__session_token,
380
   const constants__t_msg_i session_mgr__req_msg,
381
   const constants__t_msg_type_i session_mgr__req_typ,
382
   const constants__t_msg_i session_mgr__resp_msg,
383
   constants__t_session_i * const session_mgr__session,
384
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__service_ret,
385
0
   t_bool * const session_mgr__security_failed) {
386
0
   {
387
0
      t_bool session_mgr__l_valid_session;
388
0
      constants__t_sessionState_i session_mgr__l_session_state;
389
0
      constants__t_channel_i session_mgr__l_session_channel;
390
0
      t_bool session_mgr__l_is_valid_user_token;
391
0
      constants__t_user_token_i session_mgr__l_user_token;
392
0
      constants__t_channel_config_idx_i session_mgr__l_channel_config_idx;
393
0
      constants__t_endpoint_config_idx_i session_mgr__l_endpoint_config_idx;
394
0
      t_bool session_mgr__l_has_user_token_policy_available;
395
0
      t_bool session_mgr__l_session_creation_locked;
396
0
      t_entier4 session_mgr__l_nb_sessions_on_SC;
397
0
      t_bool session_mgr__l_timer_creation_ok;
398
0
      constants__t_user_i session_mgr__l_user;
399
0
      constants__t_SignatureData_i session_mgr__l_user_token_signature;
400
0
      constants__t_ApplicationDescription_i session_mgr__l_client_app_desc;
401
0
      constants__t_CertThumbprint_i session_mgr__l_client_cert_tb;
402
0
      constants__t_SessionName_i session_mgr__l_session_name;
403
      
404
0
      session_mgr__l_user = constants__c_user_indet;
405
0
      *session_mgr__security_failed = false;
406
0
      *session_mgr__session = constants__c_session_indet;
407
0
      *session_mgr__service_ret = constants_statuscodes_bs__c_StatusCode_indet;
408
0
      channel_mgr__get_channel_info(session_mgr__channel,
409
0
         &session_mgr__l_channel_config_idx);
410
0
      switch (session_mgr__req_typ) {
411
0
      case constants__e_msg_session_create_req:
412
0
         channel_mgr__server_get_endpoint_config(session_mgr__channel,
413
0
            &session_mgr__l_endpoint_config_idx);
414
0
         session_core__has_user_token_policy_available(session_mgr__l_channel_config_idx,
415
0
            session_mgr__l_endpoint_config_idx,
416
0
            &session_mgr__l_has_user_token_policy_available);
417
0
         channel_mgr__is_create_session_locked(session_mgr__channel,
418
0
            &session_mgr__l_session_creation_locked);
419
0
         session_core__get_channel_nb_sessions(session_mgr__channel,
420
0
            &session_mgr__l_nb_sessions_on_SC);
421
0
         if (((session_mgr__l_has_user_token_policy_available == true) &&
422
0
            (session_mgr__l_session_creation_locked == false)) &&
423
0
            (session_mgr__l_nb_sessions_on_SC < constants__c_max_sessions_per_channel)) {
424
0
            session_core__may_close_unactivated_session();
425
0
            session_core__server_create_session_req_and_resp_sm(session_mgr__channel,
426
0
               session_mgr__req_msg,
427
0
               session_mgr__resp_msg,
428
0
               session_mgr__session,
429
0
               session_mgr__service_ret);
430
0
            if (*session_mgr__service_ret == constants_statuscodes_bs__e_sc_ok) {
431
0
               session_core__server_session_timeout_start_timer(*session_mgr__session,
432
0
                  session_mgr__resp_msg,
433
0
                  &session_mgr__l_timer_creation_ok);
434
0
               if (session_mgr__l_timer_creation_ok == false) {
435
0
                  *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_resource_unavailable;
436
0
                  session_core__server_close_session_sm(*session_mgr__session,
437
0
                     constants_statuscodes_bs__e_sc_bad_resource_unavailable);
438
0
               }
439
0
               else {
440
0
                  session_core__may_close_unactivated_session();
441
0
               }
442
0
            }
443
0
            session_core__get_server_session_client_app_desc(*session_mgr__session,
444
0
               &session_mgr__l_client_app_desc);
445
0
            session_core__get_server_session_client_cert_tb(*session_mgr__session,
446
0
               &session_mgr__l_client_cert_tb);
447
0
            session_core__get_server_session_name(*session_mgr__session,
448
0
               &session_mgr__l_session_name);
449
0
            app_cb_call_context_bs__set_app_call_context_session(*session_mgr__session,
450
0
               session_mgr__l_client_app_desc,
451
0
               session_mgr__l_client_cert_tb,
452
0
               session_mgr__l_session_name,
453
0
               session_mgr__l_user);
454
0
         }
455
0
         else if (session_mgr__l_has_user_token_policy_available == false) {
456
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
457
0
         }
458
0
         else {
459
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_too_many_sessions;
460
0
         }
461
0
         session_core__server_notify_session_create(session_mgr__l_channel_config_idx,
462
0
            session_mgr__req_msg,
463
0
            session_mgr__resp_msg,
464
0
            *session_mgr__session,
465
0
            *session_mgr__service_ret);
466
0
         break;
467
0
      case constants__e_msg_session_activate_req:
468
0
         session_core__server_get_session_from_token(session_mgr__session_token,
469
0
            session_mgr__session);
470
0
         session_core__is_valid_session(*session_mgr__session,
471
0
            &session_mgr__l_valid_session);
472
0
         session_core__get_session_state_or_closed(*session_mgr__session,
473
0
            &session_mgr__l_session_state);
474
0
         if (session_mgr__l_valid_session == true) {
475
0
            session_core__get_server_session_client_app_desc(*session_mgr__session,
476
0
               &session_mgr__l_client_app_desc);
477
0
            session_core__get_server_session_client_cert_tb(*session_mgr__session,
478
0
               &session_mgr__l_client_cert_tb);
479
0
            session_core__get_server_session_name(*session_mgr__session,
480
0
               &session_mgr__l_session_name);
481
0
            if (((session_mgr__l_session_state == constants__e_session_created) ||
482
0
               (session_mgr__l_session_state == constants__e_session_userActivated)) ||
483
0
               (session_mgr__l_session_state == constants__e_session_scOrphaned)) {
484
0
               message_in_bs__read_activate_req_msg_identity_token(session_mgr__req_msg,
485
0
                  &session_mgr__l_is_valid_user_token,
486
0
                  &session_mgr__l_user_token,
487
0
                  &session_mgr__l_user_token_signature);
488
0
               if (session_mgr__l_is_valid_user_token == true) {
489
0
                  session_core__allocate_authenticated_user(session_mgr__channel,
490
0
                     *session_mgr__session,
491
0
                     session_mgr__l_user_token,
492
0
                     session_mgr__l_user_token_signature,
493
0
                     session_mgr__service_ret,
494
0
                     session_mgr__security_failed,
495
0
                     &session_mgr__l_user);
496
0
                  if (*session_mgr__service_ret == constants_statuscodes_bs__e_sc_ok) {
497
0
                     app_cb_call_context_bs__set_app_call_context_session(*session_mgr__session,
498
0
                        session_mgr__l_client_app_desc,
499
0
                        session_mgr__l_client_cert_tb,
500
0
                        session_mgr__l_session_name,
501
0
                        session_mgr__l_user);
502
0
                     session_core__server_activate_session_req_and_resp_sm(session_mgr__channel,
503
0
                        *session_mgr__session,
504
0
                        session_mgr__l_user,
505
0
                        session_mgr__req_msg,
506
0
                        session_mgr__resp_msg,
507
0
                        session_mgr__service_ret);
508
0
                  }
509
0
                  else if (*session_mgr__security_failed == true) {
510
0
                     session_core__server_close_session_sm(*session_mgr__session,
511
0
                        *session_mgr__service_ret);
512
0
                  }
513
0
               }
514
0
               else {
515
0
                  *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_identity_token_invalid;
516
0
               }
517
0
               if (*session_mgr__service_ret == constants_statuscodes_bs__e_sc_ok) {
518
0
                  session_core__server_session_timeout_msg_received(*session_mgr__session);
519
0
               }
520
0
            }
521
0
            else {
522
0
               session_core__server_close_session_sm(*session_mgr__session,
523
0
                  constants_statuscodes_bs__e_sc_bad_invalid_state);
524
0
               *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
525
0
            }
526
0
            app_cb_call_context_bs__set_app_call_context_session(*session_mgr__session,
527
0
               session_mgr__l_client_app_desc,
528
0
               session_mgr__l_client_cert_tb,
529
0
               session_mgr__l_session_name,
530
0
               session_mgr__l_user);
531
0
         }
532
0
         else {
533
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
534
0
         }
535
0
         session_core__server_notify_session_activate(session_mgr__l_channel_config_idx,
536
0
            session_mgr__req_msg,
537
0
            *session_mgr__session,
538
0
            *session_mgr__service_ret);
539
0
         if (*session_mgr__service_ret != constants_statuscodes_bs__e_sc_ok) {
540
0
            session_core__deallocate_user(session_mgr__l_user);
541
0
         }
542
0
         break;
543
0
      case constants__e_msg_session_close_req:
544
0
         session_core__server_get_session_from_token(session_mgr__session_token,
545
0
            session_mgr__session);
546
0
         session_core__is_valid_session(*session_mgr__session,
547
0
            &session_mgr__l_valid_session);
548
0
         session_core__get_session_state_or_closed(*session_mgr__session,
549
0
            &session_mgr__l_session_state);
550
0
         if (session_mgr__l_valid_session == true) {
551
0
            if (((session_mgr__l_session_state == constants__e_session_created) ||
552
0
               (session_mgr__l_session_state == constants__e_session_userActivating)) ||
553
0
               (session_mgr__l_session_state == constants__e_session_userActivated)) {
554
0
               if (session_mgr__l_session_state != constants__e_session_created) {
555
0
                  session_core__get_session_user_server(*session_mgr__session,
556
0
                     &session_mgr__l_user);
557
0
               }
558
0
               session_core__get_server_session_client_app_desc(*session_mgr__session,
559
0
                  &session_mgr__l_client_app_desc);
560
0
               session_core__get_server_session_client_cert_tb(*session_mgr__session,
561
0
                  &session_mgr__l_client_cert_tb);
562
0
               session_core__get_server_session_name(*session_mgr__session,
563
0
                  &session_mgr__l_session_name);
564
0
               app_cb_call_context_bs__set_app_call_context_session(*session_mgr__session,
565
0
                  session_mgr__l_client_app_desc,
566
0
                  session_mgr__l_client_cert_tb,
567
0
                  session_mgr__l_session_name,
568
0
                  session_mgr__l_user);
569
0
               session_core__get_session_channel(*session_mgr__session,
570
0
                  &session_mgr__l_session_channel);
571
0
               if (session_mgr__l_session_channel == session_mgr__channel) {
572
0
                  session_core__server_close_session_req_and_resp_sm(session_mgr__channel,
573
0
                     *session_mgr__session,
574
0
                     session_mgr__req_msg,
575
0
                     session_mgr__resp_msg,
576
0
                     session_mgr__service_ret);
577
0
               }
578
0
               else {
579
0
                  session_core__server_close_session_sm(*session_mgr__session,
580
0
                     constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid);
581
0
                  *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
582
0
               }
583
0
            }
584
0
            else {
585
0
               session_core__server_close_session_sm(*session_mgr__session,
586
0
                  constants_statuscodes_bs__e_sc_bad_invalid_state);
587
0
               *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
588
0
            }
589
0
         }
590
0
         else {
591
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
592
0
            session_core__server_notify_session_closed(*session_mgr__session,
593
0
               *session_mgr__service_ret);
594
0
         }
595
0
         break;
596
0
      default:
597
0
         *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
598
0
         break;
599
0
      }
600
0
      app_cb_call_context_bs__clear_app_call_context();
601
0
   }
602
0
}
603
604
void session_mgr__client_validate_session_service_req(
605
   const constants__t_session_i session_mgr__session,
606
   const constants__t_client_request_handle_i session_mgr__req_handle,
607
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
608
   constants__t_channel_i * const session_mgr__channel,
609
0
   constants__t_session_token_i * const session_mgr__session_token) {
610
0
   {
611
0
      constants__t_sessionState_i session_mgr__l_session_state;
612
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
613
      
614
0
      *session_mgr__session_token = constants__c_session_token_indet;
615
0
      *session_mgr__channel = constants__c_channel_indet;
616
0
      session_core__get_session_state_or_closed(session_mgr__session,
617
0
         &session_mgr__l_session_state);
618
0
      if (session_mgr__l_session_state == constants__e_session_userActivated) {
619
0
         session_core__client_get_token_from_session(session_mgr__session,
620
0
            session_mgr__session_token);
621
0
         session_core__get_session_channel(session_mgr__session,
622
0
            session_mgr__channel);
623
0
         session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
624
0
            session_mgr__req_handle);
625
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_ok;
626
0
      }
627
0
      else {
628
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
629
0
      }
630
0
      *session_mgr__ret = session_mgr__l_ret;
631
0
   }
632
0
}
633
634
void session_mgr__client_validate_session_service_req_failed(
635
   const constants__t_channel_i session_mgr__channel,
636
   const constants__t_client_request_handle_i session_mgr__req_handle,
637
0
   t_bool * const session_mgr__bres) {
638
0
   {
639
0
      constants__t_session_i session_mgr__l_session;
640
0
      constants__t_sessionState_i session_mgr__l_session_state;
641
      
642
0
      session_mgr__local_client_validate_and_drop_session_req_session_handle(session_mgr__channel,
643
0
         session_mgr__req_handle,
644
0
         session_mgr__bres,
645
0
         &session_mgr__l_session);
646
0
      if (*session_mgr__bres == true) {
647
0
         session_core__get_session_state_or_closed(session_mgr__l_session,
648
0
            &session_mgr__l_session_state);
649
0
         *session_mgr__bres = (session_mgr__l_session_state != constants__e_session_closed);
650
0
      }
651
0
   }
652
0
}
653
654
void session_mgr__client_validate_session_service_resp(
655
   const constants__t_channel_i session_mgr__channel,
656
   const constants__t_client_request_handle_i session_mgr__req_handle,
657
   t_bool * const session_mgr__bres,
658
0
   constants__t_session_i * const session_mgr__session) {
659
0
   {
660
0
      constants__t_session_i session_mgr__l_session;
661
0
      t_bool session_mgr__l_valid_session;
662
0
      constants__t_sessionState_i session_mgr__l_session_state;
663
      
664
0
      *session_mgr__session = constants__c_session_indet;
665
0
      session_mgr__local_client_validate_and_drop_session_req_session_handle(session_mgr__channel,
666
0
         session_mgr__req_handle,
667
0
         session_mgr__bres,
668
0
         &session_mgr__l_session);
669
0
      if (*session_mgr__bres == false) {
670
0
         session_core__is_valid_session(session_mgr__l_session,
671
0
            &session_mgr__l_valid_session);
672
0
         if (session_mgr__l_valid_session == true) {
673
0
            session_core__get_session_state_or_closed(session_mgr__l_session,
674
0
               &session_mgr__l_session_state);
675
0
            if (session_mgr__l_session_state != constants__e_session_userActivated) {
676
0
               session_mgr__local_client_close_session(session_mgr__l_session,
677
0
                  constants_statuscodes_bs__e_sc_bad_invalid_state);
678
0
            }
679
0
            else {
680
0
               session_mgr__local_client_close_session(session_mgr__l_session,
681
0
                  constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid);
682
0
            }
683
0
         }
684
0
      }
685
0
      else {
686
0
         *session_mgr__session = session_mgr__l_session;
687
0
      }
688
0
   }
689
0
}
690
691
void session_mgr__server_validate_session_service_req(
692
   const constants__t_channel_i session_mgr__channel,
693
   const constants__t_session_token_i session_mgr__session_token,
694
   t_bool * const session_mgr__is_valid_res,
695
   constants__t_session_i * const session_mgr__session,
696
0
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__status_code_err) {
697
0
   {
698
0
      constants__t_session_i session_mgr__l_session;
699
0
      t_bool session_mgr__l_valid_session;
700
0
      constants__t_sessionState_i session_mgr__l_session_state;
701
0
      constants__t_channel_i session_mgr__l_session_channel;
702
0
      constants__t_user_i session_mgr__l_user;
703
0
      constants__t_ApplicationDescription_i session_mgr__l_client_app_desc;
704
0
      constants__t_CertThumbprint_i session_mgr__l_client_cert_tb;
705
0
      constants__t_SessionName_i session_mgr__l_session_name;
706
      
707
0
      session_core__server_get_session_from_token(session_mgr__session_token,
708
0
         &session_mgr__l_session);
709
0
      session_core__is_valid_session(session_mgr__l_session,
710
0
         &session_mgr__l_valid_session);
711
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
712
0
         &session_mgr__l_session_state);
713
0
      *session_mgr__session = constants__c_session_indet;
714
0
      if (session_mgr__l_valid_session == true) {
715
0
         session_core__get_session_channel(session_mgr__l_session,
716
0
            &session_mgr__l_session_channel);
717
0
         if ((session_mgr__l_session_state == constants__e_session_userActivated) &&
718
0
            (session_mgr__l_session_channel == session_mgr__channel)) {
719
0
            session_core__is_session_valid_for_service(session_mgr__channel,
720
0
               session_mgr__l_session,
721
0
               session_mgr__is_valid_res);
722
0
            *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_ok;
723
0
            *session_mgr__session = session_mgr__l_session;
724
0
            if (*session_mgr__is_valid_res == true) {
725
0
               session_core__get_server_session_client_app_desc(session_mgr__l_session,
726
0
                  &session_mgr__l_client_app_desc);
727
0
               session_core__get_server_session_client_cert_tb(session_mgr__l_session,
728
0
                  &session_mgr__l_client_cert_tb);
729
0
               session_core__get_session_user_server(session_mgr__l_session,
730
0
                  &session_mgr__l_user);
731
0
               session_core__get_server_session_name(session_mgr__l_session,
732
0
                  &session_mgr__l_session_name);
733
0
               app_cb_call_context_bs__set_app_call_context_session(session_mgr__l_session,
734
0
                  session_mgr__l_client_app_desc,
735
0
                  session_mgr__l_client_cert_tb,
736
0
                  session_mgr__l_session_name,
737
0
                  session_mgr__l_user);
738
0
               session_core__server_session_timeout_msg_received(session_mgr__l_session);
739
0
            }
740
0
         }
741
0
         else {
742
0
            if (session_mgr__l_session_channel != session_mgr__channel) {
743
0
               *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
744
0
            }
745
0
            else {
746
0
               if (session_mgr__l_session_state == constants__e_session_created) {
747
0
                  *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_session_not_activated;
748
0
               }
749
0
               else {
750
0
                  *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_invalid_state;
751
0
               }
752
0
               session_core__server_close_session_sm(session_mgr__l_session,
753
0
                  *session_mgr__status_code_err);
754
0
            }
755
0
            *session_mgr__is_valid_res = false;
756
0
         }
757
0
      }
758
0
      else {
759
0
         *session_mgr__is_valid_res = false;
760
0
         *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
761
0
      }
762
0
   }
763
0
}
764
765
void session_mgr__server_validate_async_session_service_resp(
766
   const constants__t_session_i session_mgr__session,
767
   t_bool * const session_mgr__is_valid_res,
768
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__status_code_err,
769
0
   constants__t_channel_i * const session_mgr__channel) {
770
0
   {
771
0
      t_bool session_mgr__l_valid_session;
772
0
      constants__t_sessionState_i session_mgr__l_session_state;
773
0
      constants__t_channel_i session_mgr__l_session_channel;
774
      
775
0
      *session_mgr__channel = constants__c_channel_indet;
776
0
      session_core__is_valid_session(session_mgr__session,
777
0
         &session_mgr__l_valid_session);
778
0
      session_core__get_session_state_or_closed(session_mgr__session,
779
0
         &session_mgr__l_session_state);
780
0
      if (session_mgr__l_valid_session == true) {
781
0
         session_core__get_session_channel(session_mgr__session,
782
0
            &session_mgr__l_session_channel);
783
0
         if (session_mgr__l_session_state == constants__e_session_userActivated) {
784
0
            session_core__is_session_valid_for_service(session_mgr__l_session_channel,
785
0
               session_mgr__session,
786
0
               session_mgr__is_valid_res);
787
0
            *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_ok;
788
0
            *session_mgr__channel = session_mgr__l_session_channel;
789
0
         }
790
0
         else {
791
0
            *session_mgr__is_valid_res = false;
792
0
            *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_invalid_state;
793
0
         }
794
0
      }
795
0
      else {
796
0
         *session_mgr__is_valid_res = false;
797
0
         *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
798
0
      }
799
0
   }
800
0
}
801
802
void session_mgr__client_create_session_req(
803
   const constants__t_session_i session_mgr__session,
804
   const constants__t_channel_i session_mgr__channel,
805
   const constants__t_client_request_handle_i session_mgr__req_handle,
806
   const constants__t_msg_i session_mgr__create_req_msg,
807
0
   t_bool * const session_mgr__bret) {
808
0
   {
809
0
      t_bool session_mgr__l_valid_session;
810
0
      constants__t_sessionState_i session_mgr__l_session_state;
811
0
      t_bool session_mgr__l_valid;
812
0
      t_bool session_mgr__l_bret;
813
      
814
0
      session_mgr__l_bret = false;
815
0
      session_core__is_valid_session(session_mgr__session,
816
0
         &session_mgr__l_valid_session);
817
0
      session_core__get_session_state_or_closed(session_mgr__session,
818
0
         &session_mgr__l_session_state);
819
0
      if (session_mgr__l_valid_session == true) {
820
0
         if (session_mgr__l_session_state == constants__e_session_init) {
821
0
            session_core__client_create_session_req_sm(session_mgr__session,
822
0
               session_mgr__channel,
823
0
               session_mgr__create_req_msg,
824
0
               &session_mgr__l_valid);
825
0
            if (session_mgr__l_valid == true) {
826
0
               session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
827
0
                  session_mgr__req_handle);
828
0
               session_mgr__l_bret = true;
829
0
            }
830
0
            else {
831
0
               ;
832
0
            }
833
0
         }
834
0
         else {
835
0
            ;
836
0
         }
837
0
      }
838
0
      else {
839
0
         ;
840
0
      }
841
0
      *session_mgr__bret = session_mgr__l_bret;
842
0
   }
843
0
}
844
845
void session_mgr__client_async_activate_new_session_without_channel(
846
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx,
847
   const constants__t_user_token_i session_mgr__p_user_token,
848
   const constants__t_session_application_context_i session_mgr__app_context,
849
0
   t_bool * const session_mgr__bres) {
850
0
   {
851
0
      constants__t_session_i session_mgr__l_session;
852
0
      constants__t_sessionState_i session_mgr__l_session_state;
853
      
854
0
      session_core__client_init_session_sm(session_mgr__p_user_token,
855
0
         session_mgr__app_context,
856
0
         &session_mgr__l_session);
857
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
858
0
         &session_mgr__l_session_state);
859
0
      if (session_mgr__l_session_state == constants__e_session_init) {
860
0
         *session_mgr__bres = true;
861
0
         session_core__set_session_to_create(session_mgr__l_session,
862
0
            session_mgr__channel_config_idx);
863
0
      }
864
0
      else {
865
0
         *session_mgr__bres = false;
866
0
      }
867
0
   }
868
0
}
869
870
void session_mgr__client_async_activate_new_session_with_channel(
871
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx,
872
   const constants__t_channel_i session_mgr__channel,
873
   const constants__t_user_token_i session_mgr__p_user_token,
874
   const constants__t_session_application_context_i session_mgr__app_context,
875
0
   t_bool * const session_mgr__bres) {
876
0
   {
877
0
      constants__t_session_i session_mgr__l_session;
878
0
      constants__t_sessionState_i session_mgr__l_session_state;
879
      
880
0
      channel_mgr__channel_do_nothing(session_mgr__channel);
881
0
      session_core__client_init_session_sm(session_mgr__p_user_token,
882
0
         session_mgr__app_context,
883
0
         &session_mgr__l_session);
884
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
885
0
         &session_mgr__l_session_state);
886
0
      if (session_mgr__l_session_state == constants__e_session_init) {
887
0
         *session_mgr__bres = true;
888
0
         session_core__client_gen_create_session_internal_event(session_mgr__l_session,
889
0
            session_mgr__channel_config_idx);
890
0
      }
891
0
      else {
892
0
         *session_mgr__bres = false;
893
0
      }
894
0
   }
895
0
}
896
897
void session_mgr__client_user_activate_session_req(
898
   const constants__t_session_i session_mgr__session,
899
   const constants__t_client_request_handle_i session_mgr__req_handle,
900
   const constants__t_user_token_i session_mgr__p_user_token,
901
   const constants__t_msg_i session_mgr__activate_req_msg,
902
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
903
   constants__t_channel_i * const session_mgr__channel,
904
0
   constants__t_session_token_i * const session_mgr__session_token) {
905
0
   {
906
0
      t_bool session_mgr__l_valid_session;
907
0
      constants__t_sessionState_i session_mgr__l_session_state;
908
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
909
      
910
0
      session_core__is_valid_session(session_mgr__session,
911
0
         &session_mgr__l_valid_session);
912
0
      if (session_mgr__l_valid_session == true) {
913
0
         session_core__get_session_state_or_closed(session_mgr__session,
914
0
            &session_mgr__l_session_state);
915
0
         if ((session_mgr__l_session_state == constants__e_session_created) ||
916
0
            (session_mgr__l_session_state == constants__e_session_userActivated)) {
917
0
            session_core__client_user_activate_session_req_sm(session_mgr__session,
918
0
               session_mgr__p_user_token,
919
0
               session_mgr__activate_req_msg,
920
0
               &session_mgr__l_ret,
921
0
               session_mgr__channel,
922
0
               session_mgr__session_token);
923
0
            if (session_mgr__l_ret == constants_statuscodes_bs__e_sc_ok) {
924
0
               session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
925
0
                  session_mgr__req_handle);
926
0
            }
927
0
         }
928
0
         else {
929
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
930
0
            *session_mgr__channel = constants__c_channel_indet;
931
0
            *session_mgr__session_token = constants__c_session_token_indet;
932
0
         }
933
0
      }
934
0
      else {
935
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
936
0
         *session_mgr__channel = constants__c_channel_indet;
937
0
         *session_mgr__session_token = constants__c_session_token_indet;
938
0
      }
939
0
      *session_mgr__ret = session_mgr__l_ret;
940
0
   }
941
0
}
942
943
void session_mgr__client_sc_activate_session_req(
944
   const constants__t_session_i session_mgr__session,
945
   const constants__t_client_request_handle_i session_mgr__req_handle,
946
   const constants__t_channel_i session_mgr__channel,
947
   const constants__t_msg_i session_mgr__activate_req_msg,
948
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
949
0
   constants__t_session_token_i * const session_mgr__session_token) {
950
0
   {
951
0
      t_bool session_mgr__l_valid_session;
952
0
      constants__t_sessionState_i session_mgr__l_session_state;
953
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
954
      
955
0
      session_core__is_valid_session(session_mgr__session,
956
0
         &session_mgr__l_valid_session);
957
0
      if (session_mgr__l_valid_session == true) {
958
0
         session_core__get_session_state_or_closed(session_mgr__session,
959
0
            &session_mgr__l_session_state);
960
0
         if ((session_mgr__l_session_state == constants__e_session_scOrphaned) ||
961
0
            (session_mgr__l_session_state == constants__e_session_userActivated)) {
962
0
            session_core__client_sc_activate_session_req_sm(session_mgr__session,
963
0
               session_mgr__channel,
964
0
               session_mgr__activate_req_msg,
965
0
               session_mgr__session_token);
966
0
            session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
967
0
               session_mgr__req_handle);
968
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_ok;
969
0
         }
970
0
         else {
971
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
972
0
            *session_mgr__session_token = constants__c_session_token_indet;
973
0
         }
974
0
      }
975
0
      else {
976
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
977
0
         *session_mgr__session_token = constants__c_session_token_indet;
978
0
      }
979
0
      *session_mgr__ret = session_mgr__l_ret;
980
0
   }
981
0
}
982
983
void session_mgr__client_channel_connected_event_session(
984
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx,
985
0
   const constants__t_channel_i session_mgr__channel) {
986
0
   channel_mgr__channel_do_nothing(session_mgr__channel);
987
0
   session_mgr__local_client_activate_sessions_on_SC_connection(session_mgr__channel_config_idx);
988
0
}
989
990
void session_mgr__client_close_session_req(
991
   const constants__t_session_i session_mgr__session,
992
   const constants__t_client_request_handle_i session_mgr__req_handle,
993
   const constants__t_msg_i session_mgr__close_req_msg,
994
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
995
   constants__t_channel_i * const session_mgr__channel,
996
0
   constants__t_session_token_i * const session_mgr__session_token) {
997
0
   {
998
0
      t_bool session_mgr__l_valid_session;
999
0
      constants__t_sessionState_i session_mgr__l_session_state;
1000
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
1001
      
1002
0
      session_core__is_valid_session(session_mgr__session,
1003
0
         &session_mgr__l_valid_session);
1004
0
      if (session_mgr__l_valid_session == true) {
1005
0
         session_core__get_session_state_or_closed(session_mgr__session,
1006
0
            &session_mgr__l_session_state);
1007
0
         if (((session_mgr__l_session_state == constants__e_session_created) ||
1008
0
            (session_mgr__l_session_state == constants__e_session_userActivating)) ||
1009
0
            (session_mgr__l_session_state == constants__e_session_userActivated)) {
1010
0
            session_core__client_close_session_req_sm(session_mgr__session,
1011
0
               session_mgr__close_req_msg,
1012
0
               &session_mgr__l_ret,
1013
0
               session_mgr__channel,
1014
0
               session_mgr__session_token);
1015
0
            if (session_mgr__l_ret != constants_statuscodes_bs__e_sc_ok) {
1016
0
               session_mgr__local_client_close_session(session_mgr__session,
1017
0
                  session_mgr__l_ret);
1018
0
               session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_unexpected_error;
1019
0
            }
1020
0
            if (session_mgr__l_ret == constants_statuscodes_bs__e_sc_ok) {
1021
0
               session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
1022
0
                  session_mgr__req_handle);
1023
0
            }
1024
0
         }
1025
0
         else {
1026
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
1027
0
            session_mgr__local_client_close_session(session_mgr__session,
1028
0
               session_mgr__l_ret);
1029
0
            *session_mgr__channel = constants__c_channel_indet;
1030
0
            *session_mgr__session_token = constants__c_session_token_indet;
1031
0
         }
1032
0
      }
1033
0
      else {
1034
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
1035
0
         *session_mgr__channel = constants__c_channel_indet;
1036
0
         *session_mgr__session_token = constants__c_session_token_indet;
1037
0
      }
1038
0
      *session_mgr__ret = session_mgr__l_ret;
1039
0
   }
1040
0
}
1041
1042
void session_mgr__client_close_sessions_on_final_connection_failure(
1043
0
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx) {
1044
0
   session_mgr__local_client_close_sessions_on_SC_final_connection_failure(session_mgr__channel_config_idx);
1045
0
}
1046
1047
void session_mgr__client_close_session(
1048
   const constants__t_session_i session_mgr__session,
1049
0
   const constants_statuscodes_bs__t_StatusCode_i session_mgr__sc_reason) {
1050
0
   {
1051
0
      t_bool session_mgr__l_valid_session;
1052
      
1053
0
      session_core__is_valid_session(session_mgr__session,
1054
0
         &session_mgr__l_valid_session);
1055
0
      if (session_mgr__l_valid_session == true) {
1056
0
         session_mgr__local_client_close_session(session_mgr__session,
1057
0
            session_mgr__sc_reason);
1058
0
      }
1059
0
   }
1060
0
}
1061
1062
void session_mgr__server_evaluate_session_timeout(
1063
0
   const constants__t_session_i session_mgr__session) {
1064
0
   {
1065
0
      t_bool session_mgr__l_valid_session;
1066
0
      t_bool session_mgr__l_session_expired;
1067
      
1068
0
      session_core__is_valid_session(session_mgr__session,
1069
0
         &session_mgr__l_valid_session);
1070
0
      if (session_mgr__l_valid_session == true) {
1071
0
         session_core__server_session_timeout_evaluation(session_mgr__session,
1072
0
            &session_mgr__l_session_expired);
1073
0
         if (session_mgr__l_session_expired == true) {
1074
0
            session_core__server_close_session_sm(session_mgr__session,
1075
0
               constants_statuscodes_bs__e_sc_bad_timeout);
1076
0
         }
1077
0
      }
1078
0
   }
1079
0
}
1080
1081
void session_mgr__server_close_session(
1082
   const constants__t_session_i session_mgr__session,
1083
0
   const constants_statuscodes_bs__t_StatusCode_i session_mgr__sc_reason) {
1084
0
   {
1085
0
      t_bool session_mgr__l_valid_session;
1086
      
1087
0
      session_core__is_valid_session(session_mgr__session,
1088
0
         &session_mgr__l_valid_session);
1089
0
      if (session_mgr__l_valid_session == true) {
1090
0
         session_core__server_close_session_sm(session_mgr__session,
1091
0
            session_mgr__sc_reason);
1092
0
      }
1093
0
   }
1094
0
}
1095
1096
void session_mgr__session_get_endpoint_config(
1097
   const constants__t_session_i session_mgr__p_session,
1098
0
   constants__t_endpoint_config_idx_i * const session_mgr__endpoint_config_idx) {
1099
0
   session_mgr__local_session_get_endpoint_config(session_mgr__p_session,
1100
0
      session_mgr__endpoint_config_idx);
1101
0
}
1102
1103
0
void session_mgr__server_evaluate_all_session_user_cert(void) {
1104
0
   {
1105
0
      t_bool session_mgr__l_continue;
1106
0
      constants__t_session_i session_mgr__l_session;
1107
0
      t_bool session_mgr__l_valid_session;
1108
0
      t_bool session_mgr__l_server_side;
1109
0
      constants__t_endpoint_config_idx_i session_mgr__l_endpoint_config_idx;
1110
0
      t_bool session_mgr__l_valid_endpoint;
1111
0
      constants__t_user_i session_mgr__l_user;
1112
0
      constants__t_user_token_i session_mgr__l_user_token;
1113
0
      t_bool session_mgr__l_valid_token;
1114
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_valid_user;
1115
      
1116
0
      session_mgr_it__init_iter_session(&session_mgr__l_continue);
1117
0
      if (session_mgr__l_continue == true) {
1118
0
         while (session_mgr__l_continue == true) {
1119
0
            session_mgr_it__continue_iter_session(&session_mgr__l_continue,
1120
0
               &session_mgr__l_session);
1121
0
            session_core__is_valid_session(session_mgr__l_session,
1122
0
               &session_mgr__l_valid_session);
1123
0
            if (session_mgr__l_valid_session == true) {
1124
0
               session_core__session_has_user_server(session_mgr__l_session,
1125
0
                  &session_mgr__l_server_side);
1126
0
               if (session_mgr__l_server_side == true) {
1127
0
                  session_mgr__local_session_get_endpoint_config(session_mgr__l_session,
1128
0
                     &session_mgr__l_endpoint_config_idx);
1129
0
                  channel_mgr__is_valid_endpoint_config_idx(session_mgr__l_endpoint_config_idx,
1130
0
                     &session_mgr__l_valid_endpoint);
1131
0
                  if (session_mgr__l_valid_endpoint == true) {
1132
0
                     session_core__get_session_user_server(session_mgr__l_session,
1133
0
                        &session_mgr__l_user);
1134
0
                     session_core__allocate_x509_token_from_user(session_mgr__l_user,
1135
0
                        &session_mgr__l_valid_token,
1136
0
                        &session_mgr__l_user_token);
1137
0
                     if (session_mgr__l_valid_token == true) {
1138
0
                        session_core__is_valid_user_x509_authentication(session_mgr__l_endpoint_config_idx,
1139
0
                           constants__e_userTokenType_x509,
1140
0
                           session_mgr__l_user_token,
1141
0
                           &session_mgr__l_valid_user);
1142
0
                        if (session_mgr__l_valid_user != constants_statuscodes_bs__e_sc_ok) {
1143
0
                           session_core__server_close_session_sm(session_mgr__l_session,
1144
0
                              session_mgr__l_valid_user);
1145
0
                        }
1146
0
                        session_core__deallocate_x509_token(session_mgr__l_user_token);
1147
0
                     }
1148
0
                  }
1149
0
               }
1150
0
            }
1151
0
         }
1152
0
      }
1153
0
   }
1154
0
}
1155
1156
0
void session_mgr__session_mgr_UNINITIALISATION(void) {
1157
0
   session_core__session_core_UNINITIALISATION();
1158
0
}
1159