Coverage Report

Created: 2026-04-12 06:56

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