Coverage Report

Created: 2026-02-26 06:55

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                 : 09/02/2026 16:37:29
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
      
403
0
      *session_mgr__security_failed = false;
404
0
      *session_mgr__session = constants__c_session_indet;
405
0
      *session_mgr__service_ret = constants_statuscodes_bs__c_StatusCode_indet;
406
0
      channel_mgr__get_channel_info(session_mgr__channel,
407
0
         &session_mgr__l_channel_config_idx);
408
0
      switch (session_mgr__req_typ) {
409
0
      case constants__e_msg_session_create_req:
410
0
         channel_mgr__server_get_endpoint_config(session_mgr__channel,
411
0
            &session_mgr__l_endpoint_config_idx);
412
0
         session_core__has_user_token_policy_available(session_mgr__l_channel_config_idx,
413
0
            session_mgr__l_endpoint_config_idx,
414
0
            &session_mgr__l_has_user_token_policy_available);
415
0
         channel_mgr__is_create_session_locked(session_mgr__channel,
416
0
            &session_mgr__l_session_creation_locked);
417
0
         session_core__get_channel_nb_sessions(session_mgr__channel,
418
0
            &session_mgr__l_nb_sessions_on_SC);
419
0
         if (((session_mgr__l_has_user_token_policy_available == true) &&
420
0
            (session_mgr__l_session_creation_locked == false)) &&
421
0
            (session_mgr__l_nb_sessions_on_SC < constants__c_max_sessions_per_channel)) {
422
0
            session_core__may_close_unactivated_session();
423
0
            session_core__server_create_session_req_and_resp_sm(session_mgr__channel,
424
0
               session_mgr__req_msg,
425
0
               session_mgr__resp_msg,
426
0
               session_mgr__session,
427
0
               session_mgr__service_ret);
428
0
            if (*session_mgr__service_ret == constants_statuscodes_bs__e_sc_ok) {
429
0
               session_core__server_session_timeout_start_timer(*session_mgr__session,
430
0
                  session_mgr__resp_msg,
431
0
                  &session_mgr__l_timer_creation_ok);
432
0
               if (session_mgr__l_timer_creation_ok == false) {
433
0
                  *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_resource_unavailable;
434
0
                  session_core__server_close_session_sm(*session_mgr__session,
435
0
                     constants_statuscodes_bs__e_sc_bad_resource_unavailable);
436
0
               }
437
0
               else {
438
0
                  session_core__may_close_unactivated_session();
439
0
               }
440
0
            }
441
0
         }
442
0
         else if (session_mgr__l_has_user_token_policy_available == false) {
443
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
444
0
         }
445
0
         else {
446
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_too_many_sessions;
447
0
         }
448
0
         session_core__server_notify_session_create(session_mgr__l_channel_config_idx,
449
0
            session_mgr__req_msg,
450
0
            session_mgr__resp_msg,
451
0
            *session_mgr__session,
452
0
            *session_mgr__service_ret);
453
0
         break;
454
0
      case constants__e_msg_session_activate_req:
455
0
         session_core__server_get_session_from_token(session_mgr__session_token,
456
0
            session_mgr__session);
457
0
         session_core__is_valid_session(*session_mgr__session,
458
0
            &session_mgr__l_valid_session);
459
0
         session_core__get_session_state_or_closed(*session_mgr__session,
460
0
            &session_mgr__l_session_state);
461
0
         if (session_mgr__l_valid_session == true) {
462
0
            if (((session_mgr__l_session_state == constants__e_session_created) ||
463
0
               (session_mgr__l_session_state == constants__e_session_userActivated)) ||
464
0
               (session_mgr__l_session_state == constants__e_session_scOrphaned)) {
465
0
               message_in_bs__read_activate_req_msg_identity_token(session_mgr__req_msg,
466
0
                  &session_mgr__l_is_valid_user_token,
467
0
                  &session_mgr__l_user_token,
468
0
                  &session_mgr__l_user_token_signature);
469
0
               if (session_mgr__l_is_valid_user_token == true) {
470
0
                  session_core__allocate_authenticated_user(session_mgr__channel,
471
0
                     *session_mgr__session,
472
0
                     session_mgr__l_user_token,
473
0
                     session_mgr__l_user_token_signature,
474
0
                     session_mgr__service_ret,
475
0
                     session_mgr__security_failed,
476
0
                     &session_mgr__l_user);
477
0
                  if (*session_mgr__service_ret == constants_statuscodes_bs__e_sc_ok) {
478
0
                     session_core__server_activate_session_req_and_resp_sm(session_mgr__channel,
479
0
                        *session_mgr__session,
480
0
                        session_mgr__l_user,
481
0
                        session_mgr__req_msg,
482
0
                        session_mgr__resp_msg,
483
0
                        session_mgr__service_ret);
484
0
                     if (*session_mgr__service_ret != constants_statuscodes_bs__e_sc_ok) {
485
0
                        session_core__deallocate_user(session_mgr__l_user);
486
0
                     }
487
0
                  }
488
0
                  else if (*session_mgr__security_failed == true) {
489
0
                     session_core__server_close_session_sm(*session_mgr__session,
490
0
                        *session_mgr__service_ret);
491
0
                  }
492
0
               }
493
0
               else {
494
0
                  *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_identity_token_invalid;
495
0
               }
496
0
               if (*session_mgr__service_ret == constants_statuscodes_bs__e_sc_ok) {
497
0
                  session_core__server_session_timeout_msg_received(*session_mgr__session);
498
0
               }
499
0
            }
500
0
            else {
501
0
               session_core__server_close_session_sm(*session_mgr__session,
502
0
                  constants_statuscodes_bs__e_sc_bad_invalid_state);
503
0
               *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
504
0
            }
505
0
         }
506
0
         else {
507
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
508
0
         }
509
0
         session_core__server_notify_session_activate(session_mgr__l_channel_config_idx,
510
0
            session_mgr__req_msg,
511
0
            *session_mgr__session,
512
0
            *session_mgr__service_ret);
513
0
         break;
514
0
      case constants__e_msg_session_close_req:
515
0
         session_core__server_get_session_from_token(session_mgr__session_token,
516
0
            session_mgr__session);
517
0
         session_core__is_valid_session(*session_mgr__session,
518
0
            &session_mgr__l_valid_session);
519
0
         session_core__get_session_state_or_closed(*session_mgr__session,
520
0
            &session_mgr__l_session_state);
521
0
         if (session_mgr__l_valid_session == true) {
522
0
            if (((session_mgr__l_session_state == constants__e_session_created) ||
523
0
               (session_mgr__l_session_state == constants__e_session_userActivating)) ||
524
0
               (session_mgr__l_session_state == constants__e_session_userActivated)) {
525
0
               if (session_mgr__l_session_state != constants__e_session_created) {
526
0
                  session_core__get_session_user_server(*session_mgr__session,
527
0
                     &session_mgr__l_user);
528
0
                  session_core__get_server_session_client_app_desc(*session_mgr__session,
529
0
                     &session_mgr__l_client_app_desc);
530
0
                  session_core__get_server_session_client_cert_tb(*session_mgr__session,
531
0
                     &session_mgr__l_client_cert_tb);
532
0
                  app_cb_call_context_bs__set_app_call_context_session(*session_mgr__session,
533
0
                     session_mgr__l_client_app_desc,
534
0
                     session_mgr__l_client_cert_tb,
535
0
                     session_mgr__l_user);
536
0
               }
537
0
               session_core__get_session_channel(*session_mgr__session,
538
0
                  &session_mgr__l_session_channel);
539
0
               if (session_mgr__l_session_channel == session_mgr__channel) {
540
0
                  session_core__server_close_session_req_and_resp_sm(session_mgr__channel,
541
0
                     *session_mgr__session,
542
0
                     session_mgr__req_msg,
543
0
                     session_mgr__resp_msg,
544
0
                     session_mgr__service_ret);
545
0
               }
546
0
               else {
547
0
                  session_core__server_close_session_sm(*session_mgr__session,
548
0
                     constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid);
549
0
                  *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
550
0
               }
551
0
            }
552
0
            else {
553
0
               session_core__server_close_session_sm(*session_mgr__session,
554
0
                  constants_statuscodes_bs__e_sc_bad_invalid_state);
555
0
               *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
556
0
            }
557
0
         }
558
0
         else {
559
0
            *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
560
0
            session_core__server_notify_session_closed(*session_mgr__session,
561
0
               *session_mgr__service_ret);
562
0
         }
563
0
         break;
564
0
      default:
565
0
         *session_mgr__service_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
566
0
         break;
567
0
      }
568
0
   }
569
0
}
570
571
void session_mgr__client_validate_session_service_req(
572
   const constants__t_session_i session_mgr__session,
573
   const constants__t_client_request_handle_i session_mgr__req_handle,
574
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
575
   constants__t_channel_i * const session_mgr__channel,
576
0
   constants__t_session_token_i * const session_mgr__session_token) {
577
0
   {
578
0
      constants__t_sessionState_i session_mgr__l_session_state;
579
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
580
      
581
0
      *session_mgr__session_token = constants__c_session_token_indet;
582
0
      *session_mgr__channel = constants__c_channel_indet;
583
0
      session_core__get_session_state_or_closed(session_mgr__session,
584
0
         &session_mgr__l_session_state);
585
0
      if (session_mgr__l_session_state == constants__e_session_userActivated) {
586
0
         session_core__client_get_token_from_session(session_mgr__session,
587
0
            session_mgr__session_token);
588
0
         session_core__get_session_channel(session_mgr__session,
589
0
            session_mgr__channel);
590
0
         session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
591
0
            session_mgr__req_handle);
592
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_ok;
593
0
      }
594
0
      else {
595
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
596
0
      }
597
0
      *session_mgr__ret = session_mgr__l_ret;
598
0
   }
599
0
}
600
601
void session_mgr__client_validate_session_service_req_failed(
602
   const constants__t_channel_i session_mgr__channel,
603
   const constants__t_client_request_handle_i session_mgr__req_handle,
604
0
   t_bool * const session_mgr__bres) {
605
0
   {
606
0
      constants__t_session_i session_mgr__l_session;
607
0
      constants__t_sessionState_i session_mgr__l_session_state;
608
      
609
0
      session_mgr__local_client_validate_and_drop_session_req_session_handle(session_mgr__channel,
610
0
         session_mgr__req_handle,
611
0
         session_mgr__bres,
612
0
         &session_mgr__l_session);
613
0
      if (*session_mgr__bres == true) {
614
0
         session_core__get_session_state_or_closed(session_mgr__l_session,
615
0
            &session_mgr__l_session_state);
616
0
         *session_mgr__bres = (session_mgr__l_session_state != constants__e_session_closed);
617
0
      }
618
0
   }
619
0
}
620
621
void session_mgr__client_validate_session_service_resp(
622
   const constants__t_channel_i session_mgr__channel,
623
   const constants__t_client_request_handle_i session_mgr__req_handle,
624
   t_bool * const session_mgr__bres,
625
0
   constants__t_session_i * const session_mgr__session) {
626
0
   {
627
0
      constants__t_session_i session_mgr__l_session;
628
0
      t_bool session_mgr__l_valid_session;
629
0
      constants__t_sessionState_i session_mgr__l_session_state;
630
      
631
0
      *session_mgr__session = constants__c_session_indet;
632
0
      session_mgr__local_client_validate_and_drop_session_req_session_handle(session_mgr__channel,
633
0
         session_mgr__req_handle,
634
0
         session_mgr__bres,
635
0
         &session_mgr__l_session);
636
0
      if (*session_mgr__bres == false) {
637
0
         session_core__is_valid_session(session_mgr__l_session,
638
0
            &session_mgr__l_valid_session);
639
0
         if (session_mgr__l_valid_session == true) {
640
0
            session_core__get_session_state_or_closed(session_mgr__l_session,
641
0
               &session_mgr__l_session_state);
642
0
            if (session_mgr__l_session_state != constants__e_session_userActivated) {
643
0
               session_mgr__local_client_close_session(session_mgr__l_session,
644
0
                  constants_statuscodes_bs__e_sc_bad_invalid_state);
645
0
            }
646
0
            else {
647
0
               session_mgr__local_client_close_session(session_mgr__l_session,
648
0
                  constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid);
649
0
            }
650
0
         }
651
0
      }
652
0
      else {
653
0
         *session_mgr__session = session_mgr__l_session;
654
0
      }
655
0
   }
656
0
}
657
658
void session_mgr__server_validate_session_service_req(
659
   const constants__t_channel_i session_mgr__channel,
660
   const constants__t_session_token_i session_mgr__session_token,
661
   t_bool * const session_mgr__is_valid_res,
662
   constants__t_session_i * const session_mgr__session,
663
0
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__status_code_err) {
664
0
   {
665
0
      constants__t_session_i session_mgr__l_session;
666
0
      t_bool session_mgr__l_valid_session;
667
0
      constants__t_sessionState_i session_mgr__l_session_state;
668
0
      constants__t_channel_i session_mgr__l_session_channel;
669
0
      constants__t_user_i session_mgr__l_user;
670
0
      constants__t_ApplicationDescription_i session_mgr__l_client_app_desc;
671
0
      constants__t_CertThumbprint_i session_mgr__l_client_cert_tb;
672
      
673
0
      session_core__server_get_session_from_token(session_mgr__session_token,
674
0
         &session_mgr__l_session);
675
0
      session_core__is_valid_session(session_mgr__l_session,
676
0
         &session_mgr__l_valid_session);
677
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
678
0
         &session_mgr__l_session_state);
679
0
      *session_mgr__session = constants__c_session_indet;
680
0
      if (session_mgr__l_valid_session == true) {
681
0
         session_core__get_session_channel(session_mgr__l_session,
682
0
            &session_mgr__l_session_channel);
683
0
         if ((session_mgr__l_session_state == constants__e_session_userActivated) &&
684
0
            (session_mgr__l_session_channel == session_mgr__channel)) {
685
0
            session_core__is_session_valid_for_service(session_mgr__channel,
686
0
               session_mgr__l_session,
687
0
               session_mgr__is_valid_res);
688
0
            *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_ok;
689
0
            *session_mgr__session = session_mgr__l_session;
690
0
            if (*session_mgr__is_valid_res == true) {
691
0
               session_core__get_server_session_client_app_desc(session_mgr__l_session,
692
0
                  &session_mgr__l_client_app_desc);
693
0
               session_core__get_server_session_client_cert_tb(session_mgr__l_session,
694
0
                  &session_mgr__l_client_cert_tb);
695
0
               session_core__get_session_user_server(session_mgr__l_session,
696
0
                  &session_mgr__l_user);
697
0
               app_cb_call_context_bs__set_app_call_context_session(session_mgr__l_session,
698
0
                  session_mgr__l_client_app_desc,
699
0
                  session_mgr__l_client_cert_tb,
700
0
                  session_mgr__l_user);
701
0
               session_core__server_session_timeout_msg_received(session_mgr__l_session);
702
0
            }
703
0
         }
704
0
         else {
705
0
            if (session_mgr__l_session_channel != session_mgr__channel) {
706
0
               *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_secure_channel_id_invalid;
707
0
            }
708
0
            else {
709
0
               if (session_mgr__l_session_state == constants__e_session_created) {
710
0
                  *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_session_not_activated;
711
0
               }
712
0
               else {
713
0
                  *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_invalid_state;
714
0
               }
715
0
               session_core__server_close_session_sm(session_mgr__l_session,
716
0
                  *session_mgr__status_code_err);
717
0
            }
718
0
            *session_mgr__is_valid_res = false;
719
0
         }
720
0
      }
721
0
      else {
722
0
         *session_mgr__is_valid_res = false;
723
0
         *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
724
0
      }
725
0
   }
726
0
}
727
728
void session_mgr__server_validate_async_session_service_resp(
729
   const constants__t_session_i session_mgr__session,
730
   t_bool * const session_mgr__is_valid_res,
731
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__status_code_err,
732
0
   constants__t_channel_i * const session_mgr__channel) {
733
0
   {
734
0
      t_bool session_mgr__l_valid_session;
735
0
      constants__t_sessionState_i session_mgr__l_session_state;
736
0
      constants__t_channel_i session_mgr__l_session_channel;
737
      
738
0
      *session_mgr__channel = constants__c_channel_indet;
739
0
      session_core__is_valid_session(session_mgr__session,
740
0
         &session_mgr__l_valid_session);
741
0
      session_core__get_session_state_or_closed(session_mgr__session,
742
0
         &session_mgr__l_session_state);
743
0
      if (session_mgr__l_valid_session == true) {
744
0
         session_core__get_session_channel(session_mgr__session,
745
0
            &session_mgr__l_session_channel);
746
0
         if (session_mgr__l_session_state == constants__e_session_userActivated) {
747
0
            session_core__is_session_valid_for_service(session_mgr__l_session_channel,
748
0
               session_mgr__session,
749
0
               session_mgr__is_valid_res);
750
0
            *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_ok;
751
0
            *session_mgr__channel = session_mgr__l_session_channel;
752
0
         }
753
0
         else {
754
0
            *session_mgr__is_valid_res = false;
755
0
            *session_mgr__status_code_err = constants_statuscodes_bs__e_sc_bad_invalid_state;
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__client_create_session_req(
766
   const constants__t_session_i session_mgr__session,
767
   const constants__t_channel_i session_mgr__channel,
768
   const constants__t_client_request_handle_i session_mgr__req_handle,
769
   const constants__t_msg_i session_mgr__create_req_msg,
770
0
   t_bool * const session_mgr__bret) {
771
0
   {
772
0
      t_bool session_mgr__l_valid_session;
773
0
      constants__t_sessionState_i session_mgr__l_session_state;
774
0
      t_bool session_mgr__l_valid;
775
0
      t_bool session_mgr__l_bret;
776
      
777
0
      session_mgr__l_bret = false;
778
0
      session_core__is_valid_session(session_mgr__session,
779
0
         &session_mgr__l_valid_session);
780
0
      session_core__get_session_state_or_closed(session_mgr__session,
781
0
         &session_mgr__l_session_state);
782
0
      if (session_mgr__l_valid_session == true) {
783
0
         if (session_mgr__l_session_state == constants__e_session_init) {
784
0
            session_core__client_create_session_req_sm(session_mgr__session,
785
0
               session_mgr__channel,
786
0
               session_mgr__create_req_msg,
787
0
               &session_mgr__l_valid);
788
0
            if (session_mgr__l_valid == true) {
789
0
               session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
790
0
                  session_mgr__req_handle);
791
0
               session_mgr__l_bret = true;
792
0
            }
793
0
            else {
794
0
               ;
795
0
            }
796
0
         }
797
0
         else {
798
0
            ;
799
0
         }
800
0
      }
801
0
      else {
802
0
         ;
803
0
      }
804
0
      *session_mgr__bret = session_mgr__l_bret;
805
0
   }
806
0
}
807
808
void session_mgr__client_async_activate_new_session_without_channel(
809
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx,
810
   const constants__t_user_token_i session_mgr__p_user_token,
811
   const constants__t_session_application_context_i session_mgr__app_context,
812
0
   t_bool * const session_mgr__bres) {
813
0
   {
814
0
      constants__t_session_i session_mgr__l_session;
815
0
      constants__t_sessionState_i session_mgr__l_session_state;
816
      
817
0
      session_core__client_init_session_sm(session_mgr__p_user_token,
818
0
         session_mgr__app_context,
819
0
         &session_mgr__l_session);
820
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
821
0
         &session_mgr__l_session_state);
822
0
      if (session_mgr__l_session_state == constants__e_session_init) {
823
0
         *session_mgr__bres = true;
824
0
         session_core__set_session_to_create(session_mgr__l_session,
825
0
            session_mgr__channel_config_idx);
826
0
      }
827
0
      else {
828
0
         *session_mgr__bres = false;
829
0
      }
830
0
   }
831
0
}
832
833
void session_mgr__client_async_activate_new_session_with_channel(
834
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx,
835
   const constants__t_channel_i session_mgr__channel,
836
   const constants__t_user_token_i session_mgr__p_user_token,
837
   const constants__t_session_application_context_i session_mgr__app_context,
838
0
   t_bool * const session_mgr__bres) {
839
0
   {
840
0
      constants__t_session_i session_mgr__l_session;
841
0
      constants__t_sessionState_i session_mgr__l_session_state;
842
      
843
0
      channel_mgr__channel_do_nothing(session_mgr__channel);
844
0
      session_core__client_init_session_sm(session_mgr__p_user_token,
845
0
         session_mgr__app_context,
846
0
         &session_mgr__l_session);
847
0
      session_core__get_session_state_or_closed(session_mgr__l_session,
848
0
         &session_mgr__l_session_state);
849
0
      if (session_mgr__l_session_state == constants__e_session_init) {
850
0
         *session_mgr__bres = true;
851
0
         session_core__client_gen_create_session_internal_event(session_mgr__l_session,
852
0
            session_mgr__channel_config_idx);
853
0
      }
854
0
      else {
855
0
         *session_mgr__bres = false;
856
0
      }
857
0
   }
858
0
}
859
860
void session_mgr__client_user_activate_session_req(
861
   const constants__t_session_i session_mgr__session,
862
   const constants__t_client_request_handle_i session_mgr__req_handle,
863
   const constants__t_user_token_i session_mgr__p_user_token,
864
   const constants__t_msg_i session_mgr__activate_req_msg,
865
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
866
   constants__t_channel_i * const session_mgr__channel,
867
0
   constants__t_session_token_i * const session_mgr__session_token) {
868
0
   {
869
0
      t_bool session_mgr__l_valid_session;
870
0
      constants__t_sessionState_i session_mgr__l_session_state;
871
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
872
      
873
0
      session_core__is_valid_session(session_mgr__session,
874
0
         &session_mgr__l_valid_session);
875
0
      if (session_mgr__l_valid_session == true) {
876
0
         session_core__get_session_state_or_closed(session_mgr__session,
877
0
            &session_mgr__l_session_state);
878
0
         if ((session_mgr__l_session_state == constants__e_session_created) ||
879
0
            (session_mgr__l_session_state == constants__e_session_userActivated)) {
880
0
            session_core__client_user_activate_session_req_sm(session_mgr__session,
881
0
               session_mgr__p_user_token,
882
0
               session_mgr__activate_req_msg,
883
0
               &session_mgr__l_ret,
884
0
               session_mgr__channel,
885
0
               session_mgr__session_token);
886
0
            if (session_mgr__l_ret == constants_statuscodes_bs__e_sc_ok) {
887
0
               session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
888
0
                  session_mgr__req_handle);
889
0
            }
890
0
         }
891
0
         else {
892
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
893
0
            *session_mgr__channel = constants__c_channel_indet;
894
0
            *session_mgr__session_token = constants__c_session_token_indet;
895
0
         }
896
0
      }
897
0
      else {
898
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
899
0
         *session_mgr__channel = constants__c_channel_indet;
900
0
         *session_mgr__session_token = constants__c_session_token_indet;
901
0
      }
902
0
      *session_mgr__ret = session_mgr__l_ret;
903
0
   }
904
0
}
905
906
void session_mgr__client_sc_activate_session_req(
907
   const constants__t_session_i session_mgr__session,
908
   const constants__t_client_request_handle_i session_mgr__req_handle,
909
   const constants__t_channel_i session_mgr__channel,
910
   const constants__t_msg_i session_mgr__activate_req_msg,
911
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
912
0
   constants__t_session_token_i * const session_mgr__session_token) {
913
0
   {
914
0
      t_bool session_mgr__l_valid_session;
915
0
      constants__t_sessionState_i session_mgr__l_session_state;
916
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
917
      
918
0
      session_core__is_valid_session(session_mgr__session,
919
0
         &session_mgr__l_valid_session);
920
0
      if (session_mgr__l_valid_session == true) {
921
0
         session_core__get_session_state_or_closed(session_mgr__session,
922
0
            &session_mgr__l_session_state);
923
0
         if ((session_mgr__l_session_state == constants__e_session_scOrphaned) ||
924
0
            (session_mgr__l_session_state == constants__e_session_userActivated)) {
925
0
            session_core__client_sc_activate_session_req_sm(session_mgr__session,
926
0
               session_mgr__channel,
927
0
               session_mgr__activate_req_msg,
928
0
               session_mgr__session_token);
929
0
            session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
930
0
               session_mgr__req_handle);
931
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_ok;
932
0
         }
933
0
         else {
934
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
935
0
            *session_mgr__session_token = constants__c_session_token_indet;
936
0
         }
937
0
      }
938
0
      else {
939
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
940
0
         *session_mgr__session_token = constants__c_session_token_indet;
941
0
      }
942
0
      *session_mgr__ret = session_mgr__l_ret;
943
0
   }
944
0
}
945
946
void session_mgr__client_channel_connected_event_session(
947
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx,
948
0
   const constants__t_channel_i session_mgr__channel) {
949
0
   channel_mgr__channel_do_nothing(session_mgr__channel);
950
0
   session_mgr__local_client_activate_sessions_on_SC_connection(session_mgr__channel_config_idx);
951
0
}
952
953
void session_mgr__client_close_session_req(
954
   const constants__t_session_i session_mgr__session,
955
   const constants__t_client_request_handle_i session_mgr__req_handle,
956
   const constants__t_msg_i session_mgr__close_req_msg,
957
   constants_statuscodes_bs__t_StatusCode_i * const session_mgr__ret,
958
   constants__t_channel_i * const session_mgr__channel,
959
0
   constants__t_session_token_i * const session_mgr__session_token) {
960
0
   {
961
0
      t_bool session_mgr__l_valid_session;
962
0
      constants__t_sessionState_i session_mgr__l_session_state;
963
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_ret;
964
      
965
0
      session_core__is_valid_session(session_mgr__session,
966
0
         &session_mgr__l_valid_session);
967
0
      if (session_mgr__l_valid_session == true) {
968
0
         session_core__get_session_state_or_closed(session_mgr__session,
969
0
            &session_mgr__l_session_state);
970
0
         if (((session_mgr__l_session_state == constants__e_session_created) ||
971
0
            (session_mgr__l_session_state == constants__e_session_userActivating)) ||
972
0
            (session_mgr__l_session_state == constants__e_session_userActivated)) {
973
0
            session_core__client_close_session_req_sm(session_mgr__session,
974
0
               session_mgr__close_req_msg,
975
0
               &session_mgr__l_ret,
976
0
               session_mgr__channel,
977
0
               session_mgr__session_token);
978
0
            if (session_mgr__l_ret != constants_statuscodes_bs__e_sc_ok) {
979
0
               session_mgr__local_client_close_session(session_mgr__session,
980
0
                  session_mgr__l_ret);
981
0
               session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_unexpected_error;
982
0
            }
983
0
            if (session_mgr__l_ret == constants_statuscodes_bs__e_sc_ok) {
984
0
               session_request_handle_bs__client_add_session_request_handle(session_mgr__session,
985
0
                  session_mgr__req_handle);
986
0
            }
987
0
         }
988
0
         else {
989
0
            session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_state;
990
0
            session_mgr__local_client_close_session(session_mgr__session,
991
0
               session_mgr__l_ret);
992
0
            *session_mgr__channel = constants__c_channel_indet;
993
0
            *session_mgr__session_token = constants__c_session_token_indet;
994
0
         }
995
0
      }
996
0
      else {
997
0
         session_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
998
0
         *session_mgr__channel = constants__c_channel_indet;
999
0
         *session_mgr__session_token = constants__c_session_token_indet;
1000
0
      }
1001
0
      *session_mgr__ret = session_mgr__l_ret;
1002
0
   }
1003
0
}
1004
1005
void session_mgr__client_close_sessions_on_final_connection_failure(
1006
0
   const constants__t_channel_config_idx_i session_mgr__channel_config_idx) {
1007
0
   session_mgr__local_client_close_sessions_on_SC_final_connection_failure(session_mgr__channel_config_idx);
1008
0
}
1009
1010
void session_mgr__client_close_session(
1011
   const constants__t_session_i session_mgr__session,
1012
0
   const constants_statuscodes_bs__t_StatusCode_i session_mgr__sc_reason) {
1013
0
   {
1014
0
      t_bool session_mgr__l_valid_session;
1015
      
1016
0
      session_core__is_valid_session(session_mgr__session,
1017
0
         &session_mgr__l_valid_session);
1018
0
      if (session_mgr__l_valid_session == true) {
1019
0
         session_mgr__local_client_close_session(session_mgr__session,
1020
0
            session_mgr__sc_reason);
1021
0
      }
1022
0
   }
1023
0
}
1024
1025
void session_mgr__server_evaluate_session_timeout(
1026
0
   const constants__t_session_i session_mgr__session) {
1027
0
   {
1028
0
      t_bool session_mgr__l_valid_session;
1029
0
      t_bool session_mgr__l_session_expired;
1030
      
1031
0
      session_core__is_valid_session(session_mgr__session,
1032
0
         &session_mgr__l_valid_session);
1033
0
      if (session_mgr__l_valid_session == true) {
1034
0
         session_core__server_session_timeout_evaluation(session_mgr__session,
1035
0
            &session_mgr__l_session_expired);
1036
0
         if (session_mgr__l_session_expired == true) {
1037
0
            session_core__server_close_session_sm(session_mgr__session,
1038
0
               constants_statuscodes_bs__e_sc_bad_timeout);
1039
0
         }
1040
0
      }
1041
0
   }
1042
0
}
1043
1044
void session_mgr__server_close_session(
1045
   const constants__t_session_i session_mgr__session,
1046
0
   const constants_statuscodes_bs__t_StatusCode_i session_mgr__sc_reason) {
1047
0
   {
1048
0
      t_bool session_mgr__l_valid_session;
1049
      
1050
0
      session_core__is_valid_session(session_mgr__session,
1051
0
         &session_mgr__l_valid_session);
1052
0
      if (session_mgr__l_valid_session == true) {
1053
0
         session_core__server_close_session_sm(session_mgr__session,
1054
0
            session_mgr__sc_reason);
1055
0
      }
1056
0
   }
1057
0
}
1058
1059
void session_mgr__session_get_endpoint_config(
1060
   const constants__t_session_i session_mgr__p_session,
1061
0
   constants__t_endpoint_config_idx_i * const session_mgr__endpoint_config_idx) {
1062
0
   session_mgr__local_session_get_endpoint_config(session_mgr__p_session,
1063
0
      session_mgr__endpoint_config_idx);
1064
0
}
1065
1066
0
void session_mgr__server_evaluate_all_session_user_cert(void) {
1067
0
   {
1068
0
      t_bool session_mgr__l_continue;
1069
0
      constants__t_session_i session_mgr__l_session;
1070
0
      t_bool session_mgr__l_valid_session;
1071
0
      t_bool session_mgr__l_server_side;
1072
0
      constants__t_endpoint_config_idx_i session_mgr__l_endpoint_config_idx;
1073
0
      t_bool session_mgr__l_valid_endpoint;
1074
0
      constants__t_user_i session_mgr__l_user;
1075
0
      constants__t_user_token_i session_mgr__l_user_token;
1076
0
      t_bool session_mgr__l_valid_token;
1077
0
      constants_statuscodes_bs__t_StatusCode_i session_mgr__l_valid_user;
1078
      
1079
0
      session_mgr_it__init_iter_session(&session_mgr__l_continue);
1080
0
      if (session_mgr__l_continue == true) {
1081
0
         while (session_mgr__l_continue == true) {
1082
0
            session_mgr_it__continue_iter_session(&session_mgr__l_continue,
1083
0
               &session_mgr__l_session);
1084
0
            session_core__is_valid_session(session_mgr__l_session,
1085
0
               &session_mgr__l_valid_session);
1086
0
            if (session_mgr__l_valid_session == true) {
1087
0
               session_core__session_has_user_server(session_mgr__l_session,
1088
0
                  &session_mgr__l_server_side);
1089
0
               if (session_mgr__l_server_side == true) {
1090
0
                  session_mgr__local_session_get_endpoint_config(session_mgr__l_session,
1091
0
                     &session_mgr__l_endpoint_config_idx);
1092
0
                  channel_mgr__is_valid_endpoint_config_idx(session_mgr__l_endpoint_config_idx,
1093
0
                     &session_mgr__l_valid_endpoint);
1094
0
                  if (session_mgr__l_valid_endpoint == true) {
1095
0
                     session_core__get_session_user_server(session_mgr__l_session,
1096
0
                        &session_mgr__l_user);
1097
0
                     session_core__allocate_x509_token_from_user(session_mgr__l_user,
1098
0
                        &session_mgr__l_valid_token,
1099
0
                        &session_mgr__l_user_token);
1100
0
                     if (session_mgr__l_valid_token == true) {
1101
0
                        session_core__is_valid_user_x509_authentication(session_mgr__l_endpoint_config_idx,
1102
0
                           constants__e_userTokenType_x509,
1103
0
                           session_mgr__l_user_token,
1104
0
                           &session_mgr__l_valid_user);
1105
0
                        if (session_mgr__l_valid_user != constants_statuscodes_bs__e_sc_ok) {
1106
0
                           session_core__server_close_session_sm(session_mgr__l_session,
1107
0
                              session_mgr__l_valid_user);
1108
0
                        }
1109
0
                        session_core__deallocate_x509_token(session_mgr__l_user_token);
1110
0
                     }
1111
0
                  }
1112
0
               }
1113
0
            }
1114
0
         }
1115
0
      }
1116
0
   }
1117
0
}
1118
1119
0
void session_mgr__session_mgr_UNINITIALISATION(void) {
1120
0
   session_core__session_core_UNINITIALISATION();
1121
0
}
1122