Coverage Report

Created: 2026-03-07 06:40

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/S2OPC/src/ClientServer/services/bgenc/service_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            : service_mgr.c
23
24
 Date                 : 09/02/2026 16:37:25
25
26
 C Translator Version : tradc Java V1.2 (06/02/2022)
27
28
******************************************************************************/
29
30
/*------------------------
31
   Exported Declarations
32
  ------------------------*/
33
#include "service_mgr.h"
34
35
/*------------------------
36
   INITIALISATION Clause
37
  ------------------------*/
38
0
void service_mgr__INITIALISATION(void) {
39
0
}
40
41
/*--------------------
42
   OPERATIONS Clause
43
  --------------------*/
44
void service_mgr__get_response_type(
45
   const constants__t_msg_type_i service_mgr__req_msg_typ,
46
0
   constants__t_msg_type_i * const service_mgr__resp_msg_typ) {
47
0
   *service_mgr__resp_msg_typ = constants__c_msg_type_indet;
48
0
   switch (service_mgr__req_msg_typ) {
49
0
   case constants__e_msg_discovery_find_servers_req:
50
0
      *service_mgr__resp_msg_typ = constants__e_msg_discovery_find_servers_resp;
51
0
      break;
52
0
   case constants__e_msg_discovery_find_servers_on_network_req:
53
0
      *service_mgr__resp_msg_typ = constants__e_msg_discovery_find_servers_on_network_resp;
54
0
      break;
55
0
   case constants__e_msg_discovery_get_endpoints_req:
56
0
      *service_mgr__resp_msg_typ = constants__e_msg_discovery_get_endpoints_resp;
57
0
      break;
58
0
   case constants__e_msg_discovery_register_server_req:
59
0
      *service_mgr__resp_msg_typ = constants__e_msg_discovery_register_server_resp;
60
0
      break;
61
0
   case constants__e_msg_discovery_register_server2_req:
62
0
      *service_mgr__resp_msg_typ = constants__e_msg_discovery_register_server2_resp;
63
0
      break;
64
0
   case constants__e_msg_session_create_req:
65
0
      *service_mgr__resp_msg_typ = constants__e_msg_session_create_resp;
66
0
      break;
67
0
   case constants__e_msg_session_activate_req:
68
0
      *service_mgr__resp_msg_typ = constants__e_msg_session_activate_resp;
69
0
      break;
70
0
   case constants__e_msg_session_close_req:
71
0
      *service_mgr__resp_msg_typ = constants__e_msg_session_close_resp;
72
0
      break;
73
0
   case constants__e_msg_session_cancel_req:
74
0
      *service_mgr__resp_msg_typ = constants__e_msg_session_cancel_resp;
75
0
      break;
76
0
   case constants__e_msg_node_add_nodes_req:
77
0
      *service_mgr__resp_msg_typ = constants__e_msg_node_add_nodes_resp;
78
0
      break;
79
0
   case constants__e_msg_node_add_references_req:
80
0
      *service_mgr__resp_msg_typ = constants__e_msg_node_add_references_resp;
81
0
      break;
82
0
   case constants__e_msg_node_delete_nodes_req:
83
0
      *service_mgr__resp_msg_typ = constants__e_msg_node_delete_nodes_resp;
84
0
      break;
85
0
   case constants__e_msg_node_delete_references_req:
86
0
      *service_mgr__resp_msg_typ = constants__e_msg_node_delete_references_resp;
87
0
      break;
88
0
   case constants__e_msg_view_browse_req:
89
0
      *service_mgr__resp_msg_typ = constants__e_msg_view_browse_resp;
90
0
      break;
91
0
   case constants__e_msg_view_browse_next_req:
92
0
      *service_mgr__resp_msg_typ = constants__e_msg_view_browse_next_resp;
93
0
      break;
94
0
   case constants__e_msg_view_translate_browse_paths_to_node_ids_req:
95
0
      *service_mgr__resp_msg_typ = constants__e_msg_view_translate_browse_paths_to_node_ids_resp;
96
0
      break;
97
0
   case constants__e_msg_view_register_nodes_req:
98
0
      *service_mgr__resp_msg_typ = constants__e_msg_view_register_nodes_resp;
99
0
      break;
100
0
   case constants__e_msg_view_unregister_nodes_req:
101
0
      *service_mgr__resp_msg_typ = constants__e_msg_view_unregister_nodes_resp;
102
0
      break;
103
0
   case constants__e_msg_query_first_req:
104
0
      *service_mgr__resp_msg_typ = constants__e_msg_query_first_resp;
105
0
      break;
106
0
   case constants__e_msg_query_next_req:
107
0
      *service_mgr__resp_msg_typ = constants__e_msg_query_next_resp;
108
0
      break;
109
0
   case constants__e_msg_attribute_read_req:
110
0
      *service_mgr__resp_msg_typ = constants__e_msg_attribute_read_resp;
111
0
      break;
112
0
   case constants__e_msg_attribute_history_read_req:
113
0
      *service_mgr__resp_msg_typ = constants__e_msg_attribute_history_read_resp;
114
0
      break;
115
0
   case constants__e_msg_attribute_write_req:
116
0
      *service_mgr__resp_msg_typ = constants__e_msg_attribute_write_resp;
117
0
      break;
118
0
   case constants__e_msg_attribute_history_update_req:
119
0
      *service_mgr__resp_msg_typ = constants__e_msg_attribute_history_update_resp;
120
0
      break;
121
0
   case constants__e_msg_method_call_req:
122
0
      *service_mgr__resp_msg_typ = constants__e_msg_method_call_resp;
123
0
      break;
124
0
   case constants__e_msg_monitored_items_create_req:
125
0
      *service_mgr__resp_msg_typ = constants__e_msg_monitored_items_create_resp;
126
0
      break;
127
0
   case constants__e_msg_monitored_items_modify_req:
128
0
      *service_mgr__resp_msg_typ = constants__e_msg_monitored_items_modify_resp;
129
0
      break;
130
0
   case constants__e_msg_monitored_items_set_monitoring_mode_req:
131
0
      *service_mgr__resp_msg_typ = constants__e_msg_monitored_items_set_monitoring_mode_resp;
132
0
      break;
133
0
   case constants__e_msg_monitored_items_set_triggering_req:
134
0
      *service_mgr__resp_msg_typ = constants__e_msg_monitored_items_set_triggering_resp;
135
0
      break;
136
0
   case constants__e_msg_monitored_items_delete_req:
137
0
      *service_mgr__resp_msg_typ = constants__e_msg_monitored_items_delete_resp;
138
0
      break;
139
0
   case constants__e_msg_subscription_create_req:
140
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_create_resp;
141
0
      break;
142
0
   case constants__e_msg_subscription_modify_req:
143
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_modify_resp;
144
0
      break;
145
0
   case constants__e_msg_subscription_set_publishing_mode_req:
146
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_set_publishing_mode_resp;
147
0
      break;
148
0
   case constants__e_msg_subscription_publish_req:
149
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_publish_resp;
150
0
      break;
151
0
   case constants__e_msg_subscription_republish_req:
152
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_republish_resp;
153
0
      break;
154
0
   case constants__e_msg_subscription_transfer_subscriptions_req:
155
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_transfer_subscriptions_resp;
156
0
      break;
157
0
   case constants__e_msg_subscription_delete_subscriptions_req:
158
0
      *service_mgr__resp_msg_typ = constants__e_msg_subscription_delete_subscriptions_resp;
159
0
      break;
160
0
   default:
161
0
      break;
162
0
   }
163
0
}
164
165
void service_mgr__l_get_msg_service_class(
166
   const constants__t_msg_type_i service_mgr__msg_typ,
167
0
   constants__t_msg_service_class_i * const service_mgr__service_class) {
168
0
   switch (service_mgr__msg_typ) {
169
0
   case constants__e_msg_discovery_find_servers_req:
170
0
   case constants__e_msg_discovery_find_servers_resp:
171
0
   case constants__e_msg_discovery_find_servers_on_network_req:
172
0
   case constants__e_msg_discovery_find_servers_on_network_resp:
173
0
   case constants__e_msg_discovery_get_endpoints_req:
174
0
   case constants__e_msg_discovery_get_endpoints_resp:
175
0
   case constants__e_msg_discovery_register_server_req:
176
0
   case constants__e_msg_discovery_register_server_resp:
177
0
   case constants__e_msg_discovery_register_server2_req:
178
0
   case constants__e_msg_discovery_register_server2_resp:
179
0
      *service_mgr__service_class = constants__e_msg_discovery_service_class;
180
0
      break;
181
0
   case constants__e_msg_session_create_req:
182
0
   case constants__e_msg_session_create_resp:
183
0
   case constants__e_msg_session_activate_req:
184
0
   case constants__e_msg_session_activate_resp:
185
0
   case constants__e_msg_session_close_req:
186
0
   case constants__e_msg_session_close_resp:
187
0
   case constants__e_msg_session_cancel_req:
188
0
   case constants__e_msg_session_cancel_resp:
189
0
      *service_mgr__service_class = constants__e_msg_session_treatment_class;
190
0
      break;
191
0
   case constants__e_msg_node_add_nodes_req:
192
0
   case constants__e_msg_node_add_nodes_resp:
193
0
   case constants__e_msg_node_add_references_req:
194
0
   case constants__e_msg_node_add_references_resp:
195
0
   case constants__e_msg_node_delete_nodes_req:
196
0
   case constants__e_msg_node_delete_nodes_resp:
197
0
   case constants__e_msg_node_delete_references_req:
198
0
   case constants__e_msg_node_delete_references_resp:
199
0
   case constants__e_msg_view_browse_req:
200
0
   case constants__e_msg_view_browse_resp:
201
0
   case constants__e_msg_view_browse_next_req:
202
0
   case constants__e_msg_view_browse_next_resp:
203
0
   case constants__e_msg_view_translate_browse_paths_to_node_ids_req:
204
0
   case constants__e_msg_view_translate_browse_paths_to_node_ids_resp:
205
0
   case constants__e_msg_view_register_nodes_req:
206
0
   case constants__e_msg_view_register_nodes_resp:
207
0
   case constants__e_msg_view_unregister_nodes_req:
208
0
   case constants__e_msg_view_unregister_nodes_resp:
209
0
   case constants__e_msg_query_first_req:
210
0
   case constants__e_msg_query_first_resp:
211
0
   case constants__e_msg_query_next_req:
212
0
   case constants__e_msg_query_next_resp:
213
0
   case constants__e_msg_attribute_read_req:
214
0
   case constants__e_msg_attribute_read_resp:
215
0
   case constants__e_msg_attribute_history_read_req:
216
0
   case constants__e_msg_attribute_history_read_resp:
217
0
   case constants__e_msg_attribute_write_req:
218
0
   case constants__e_msg_attribute_write_resp:
219
0
   case constants__e_msg_attribute_history_update_req:
220
0
   case constants__e_msg_attribute_history_update_resp:
221
0
   case constants__e_msg_method_call_req:
222
0
   case constants__e_msg_method_call_resp:
223
0
   case constants__e_msg_monitored_items_create_req:
224
0
   case constants__e_msg_monitored_items_create_resp:
225
0
   case constants__e_msg_monitored_items_modify_req:
226
0
   case constants__e_msg_monitored_items_modify_resp:
227
0
   case constants__e_msg_monitored_items_set_monitoring_mode_req:
228
0
   case constants__e_msg_monitored_items_set_monitoring_mode_resp:
229
0
   case constants__e_msg_monitored_items_set_triggering_req:
230
0
   case constants__e_msg_monitored_items_set_triggering_resp:
231
0
   case constants__e_msg_monitored_items_delete_req:
232
0
   case constants__e_msg_monitored_items_delete_resp:
233
0
   case constants__e_msg_subscription_create_req:
234
0
   case constants__e_msg_subscription_create_resp:
235
0
   case constants__e_msg_subscription_modify_req:
236
0
   case constants__e_msg_subscription_modify_resp:
237
0
   case constants__e_msg_subscription_set_publishing_mode_req:
238
0
   case constants__e_msg_subscription_set_publishing_mode_resp:
239
0
   case constants__e_msg_subscription_publish_req:
240
0
   case constants__e_msg_subscription_publish_resp:
241
0
   case constants__e_msg_subscription_republish_req:
242
0
   case constants__e_msg_subscription_republish_resp:
243
0
   case constants__e_msg_subscription_transfer_subscriptions_req:
244
0
   case constants__e_msg_subscription_transfer_subscriptions_resp:
245
0
   case constants__e_msg_subscription_delete_subscriptions_req:
246
0
   case constants__e_msg_subscription_delete_subscriptions_resp:
247
0
      *service_mgr__service_class = constants__e_msg_session_service_class;
248
0
      break;
249
0
   default:
250
0
      *service_mgr__service_class = constants__e_msg_service_fault_class;
251
0
      break;
252
0
   }
253
0
}
254
255
void service_mgr__get_msg_service_class(
256
   const constants__t_msg_type_i service_mgr__msg_typ,
257
0
   constants__t_msg_service_class_i * const service_mgr__service_class) {
258
0
   service_mgr__l_get_msg_service_class(service_mgr__msg_typ,
259
0
      service_mgr__service_class);
260
0
}
261
262
void service_mgr__treat_session_local_service_req(
263
   const constants__t_endpoint_config_idx_i service_mgr__endpoint_config_idx,
264
   const constants__t_msg_type_i service_mgr__req_typ,
265
   const constants__t_msg_i service_mgr__req_msg,
266
   const constants__t_msg_i service_mgr__resp_msg,
267
0
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__StatusCode_service) {
268
0
   {
269
0
      constants__t_user_i service_mgr__l_user;
270
0
      constants__t_LocaleIds_i service_mgr__l_supported_locales;
271
0
      t_bool service_mgr__l_node_management_done;
272
      
273
0
      service_mgr__l_node_management_done = false;
274
0
      switch (service_mgr__req_typ) {
275
0
      case constants__e_msg_attribute_read_req:
276
0
         session_mgr__get_local_user(service_mgr__endpoint_config_idx,
277
0
            &service_mgr__l_user);
278
0
         constants__get_SupportedLocales(service_mgr__endpoint_config_idx,
279
0
            &service_mgr__l_supported_locales);
280
0
         service_read__treat_read_request(service_mgr__l_user,
281
0
            service_mgr__l_supported_locales,
282
0
            service_mgr__req_msg,
283
0
            service_mgr__resp_msg,
284
0
            service_mgr__StatusCode_service);
285
0
         break;
286
0
      case constants__e_msg_attribute_write_req:
287
0
         session_mgr__get_local_user(service_mgr__endpoint_config_idx,
288
0
            &service_mgr__l_user);
289
0
         constants__get_SupportedLocales(service_mgr__endpoint_config_idx,
290
0
            &service_mgr__l_supported_locales);
291
0
         address_space_itf__treat_write_request(service_mgr__l_user,
292
0
            service_mgr__l_supported_locales,
293
0
            service_mgr__req_msg,
294
0
            service_mgr__resp_msg,
295
0
            service_mgr__StatusCode_service);
296
0
         break;
297
0
      case constants__e_msg_view_browse_req:
298
0
         service_set_view__treat_browse_request(constants__c_session_indet,
299
0
            service_mgr__req_msg,
300
0
            service_mgr__resp_msg,
301
0
            service_mgr__StatusCode_service);
302
0
         break;
303
0
      case constants__e_msg_view_translate_browse_paths_to_node_ids_req:
304
0
         service_set_view__treat_translate_browse_paths_request(service_mgr__req_msg,
305
0
            service_mgr__resp_msg,
306
0
            service_mgr__StatusCode_service);
307
0
         break;
308
0
      case constants__e_msg_node_add_nodes_req:
309
0
         session_mgr__get_local_user(service_mgr__endpoint_config_idx,
310
0
            &service_mgr__l_user);
311
0
         address_space_itf__treat_add_nodes_request(service_mgr__l_user,
312
0
            service_mgr__req_msg,
313
0
            service_mgr__resp_msg,
314
0
            service_mgr__StatusCode_service);
315
0
         service_mgr__l_node_management_done = (*service_mgr__StatusCode_service == constants_statuscodes_bs__e_sc_ok);
316
0
         break;
317
0
      case constants__e_msg_node_delete_nodes_req:
318
0
         session_mgr__get_local_user(service_mgr__endpoint_config_idx,
319
0
            &service_mgr__l_user);
320
0
         address_space_itf__treat_delete_nodes_request(service_mgr__l_user,
321
0
            service_mgr__req_msg,
322
0
            service_mgr__resp_msg,
323
0
            service_mgr__StatusCode_service);
324
0
         service_mgr__l_node_management_done = (*service_mgr__StatusCode_service == constants_statuscodes_bs__e_sc_ok);
325
0
         break;
326
0
      default:
327
0
         *service_mgr__StatusCode_service = constants_statuscodes_bs__e_sc_bad_service_unsupported;
328
0
         break;
329
0
      }
330
0
      if (service_mgr__l_node_management_done == true) {
331
0
         service_set_view__service_set_view_service_node_management_used();
332
0
      }
333
0
   }
334
0
}
335
336
void service_mgr__treat_session_nano_service_req(
337
   const constants__t_endpoint_config_idx_i service_mgr__endpoint_config_idx,
338
   const constants__t_session_i service_mgr__session,
339
   const constants__t_msg_type_i service_mgr__req_typ,
340
   const constants__t_msg_i service_mgr__req_msg,
341
   const constants__t_msg_i service_mgr__resp_msg,
342
0
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__StatusCode_service) {
343
0
   {
344
0
      constants__t_user_i service_mgr__l_user;
345
0
      constants__t_LocaleIds_i service_mgr__l_locales;
346
      
347
0
      switch (service_mgr__req_typ) {
348
0
      case constants__e_msg_attribute_read_req:
349
0
         session_mgr__get_session_user_server(service_mgr__session,
350
0
            &service_mgr__l_user);
351
0
         session_mgr__get_server_session_preferred_locales(service_mgr__session,
352
0
            &service_mgr__l_locales);
353
0
         service_read__treat_read_request(service_mgr__l_user,
354
0
            service_mgr__l_locales,
355
0
            service_mgr__req_msg,
356
0
            service_mgr__resp_msg,
357
0
            service_mgr__StatusCode_service);
358
0
         break;
359
0
      case constants__e_msg_attribute_write_req:
360
0
         session_mgr__get_session_user_server(service_mgr__session,
361
0
            &service_mgr__l_user);
362
0
         constants__get_SupportedLocales(service_mgr__endpoint_config_idx,
363
0
            &service_mgr__l_locales);
364
0
         address_space_itf__treat_write_request(service_mgr__l_user,
365
0
            service_mgr__l_locales,
366
0
            service_mgr__req_msg,
367
0
            service_mgr__resp_msg,
368
0
            service_mgr__StatusCode_service);
369
0
         break;
370
0
      case constants__e_msg_view_browse_req:
371
0
         service_set_view__treat_browse_request(service_mgr__session,
372
0
            service_mgr__req_msg,
373
0
            service_mgr__resp_msg,
374
0
            service_mgr__StatusCode_service);
375
0
         break;
376
0
      case constants__e_msg_view_browse_next_req:
377
0
         service_set_view__treat_browse_next_request(service_mgr__session,
378
0
            service_mgr__req_msg,
379
0
            service_mgr__resp_msg,
380
0
            service_mgr__StatusCode_service);
381
0
         break;
382
0
      case constants__e_msg_view_translate_browse_paths_to_node_ids_req:
383
0
         service_set_view__treat_translate_browse_paths_request(service_mgr__req_msg,
384
0
            service_mgr__resp_msg,
385
0
            service_mgr__StatusCode_service);
386
0
         break;
387
0
      case constants__e_msg_view_register_nodes_req:
388
0
         service_register_nodes__treat_register_nodes_request(service_mgr__req_msg,
389
0
            service_mgr__resp_msg,
390
0
            service_mgr__StatusCode_service);
391
0
         break;
392
0
      case constants__e_msg_view_unregister_nodes_req:
393
0
         service_unregister_nodes__treat_unregister_nodes_request(service_mgr__req_msg,
394
0
            service_mgr__StatusCode_service);
395
0
         break;
396
0
      default:
397
0
         *service_mgr__StatusCode_service = constants_statuscodes_bs__e_sc_bad_service_unsupported;
398
0
         break;
399
0
      }
400
0
   }
401
0
}
402
403
void service_mgr__treat_session_nano_extended_service_req(
404
   const constants__t_endpoint_config_idx_i service_mgr__endpoint_config_idx,
405
   const constants__t_session_i service_mgr__session,
406
   const constants__t_msg_type_i service_mgr__req_typ,
407
   const constants__t_server_request_handle_i service_mgr__req_handle,
408
   const constants__t_request_context_i service_mgr__req_ctx,
409
   const constants__t_msg_header_i service_mgr__req_header,
410
   const constants__t_msg_i service_mgr__req_msg,
411
   const constants__t_msg_i service_mgr__resp_msg,
412
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__StatusCode_service,
413
0
   t_bool * const service_mgr__async_resp_msg) {
414
0
   {
415
0
      constants__t_user_i service_mgr__l_user;
416
0
      t_bool service_mgr__l_node_management_done;
417
0
      t_bool service_mgr__l_bres;
418
      
419
0
      service_mgr__l_node_management_done = false;
420
0
      *service_mgr__async_resp_msg = false;
421
0
      switch (service_mgr__req_typ) {
422
0
      case constants__e_msg_attribute_read_req:
423
0
      case constants__e_msg_attribute_write_req:
424
0
      case constants__e_msg_view_browse_req:
425
0
      case constants__e_msg_view_browse_next_req:
426
0
      case constants__e_msg_view_translate_browse_paths_to_node_ids_req:
427
0
      case constants__e_msg_view_register_nodes_req:
428
0
      case constants__e_msg_view_unregister_nodes_req:
429
0
         service_mgr__treat_session_nano_service_req(service_mgr__endpoint_config_idx,
430
0
            service_mgr__session,
431
0
            service_mgr__req_typ,
432
0
            service_mgr__req_msg,
433
0
            service_mgr__resp_msg,
434
0
            service_mgr__StatusCode_service);
435
0
         break;
436
0
      case constants__e_msg_subscription_create_req:
437
0
         subscription_mgr__treat_create_subscription_request(service_mgr__session,
438
0
            service_mgr__req_msg,
439
0
            service_mgr__resp_msg,
440
0
            service_mgr__StatusCode_service);
441
0
         break;
442
0
      case constants__e_msg_subscription_modify_req:
443
0
         subscription_mgr__treat_modify_subscription_request(service_mgr__session,
444
0
            service_mgr__req_msg,
445
0
            service_mgr__resp_msg,
446
0
            service_mgr__StatusCode_service);
447
0
         break;
448
0
      case constants__e_msg_subscription_delete_subscriptions_req:
449
0
         subscription_mgr__treat_delete_subscriptions_request(service_mgr__session,
450
0
            service_mgr__req_msg,
451
0
            service_mgr__resp_msg,
452
0
            service_mgr__StatusCode_service);
453
0
         break;
454
0
      case constants__e_msg_subscription_set_publishing_mode_req:
455
0
         subscription_mgr__treat_publishing_mode_request(service_mgr__session,
456
0
            service_mgr__req_msg,
457
0
            service_mgr__resp_msg,
458
0
            service_mgr__StatusCode_service);
459
0
         break;
460
0
      case constants__e_msg_subscription_publish_req:
461
0
         subscription_mgr__treat_subscription_publish_request(service_mgr__session,
462
0
            service_mgr__req_header,
463
0
            service_mgr__req_msg,
464
0
            service_mgr__req_handle,
465
0
            service_mgr__req_ctx,
466
0
            service_mgr__resp_msg,
467
0
            service_mgr__StatusCode_service,
468
0
            service_mgr__async_resp_msg);
469
0
         break;
470
0
      case constants__e_msg_subscription_republish_req:
471
0
         subscription_mgr__treat_subscription_republish_request(service_mgr__session,
472
0
            service_mgr__req_msg,
473
0
            service_mgr__resp_msg,
474
0
            service_mgr__StatusCode_service);
475
0
         break;
476
0
      case constants__e_msg_monitored_items_create_req:
477
0
         session_mgr__get_session_user_server(service_mgr__session,
478
0
            &service_mgr__l_user);
479
0
         subscription_mgr__treat_subscription_create_monitored_items_req(service_mgr__session,
480
0
            service_mgr__l_user,
481
0
            service_mgr__req_msg,
482
0
            service_mgr__resp_msg,
483
0
            service_mgr__StatusCode_service);
484
0
         break;
485
0
      case constants__e_msg_monitored_items_modify_req:
486
0
         subscription_mgr__treat_subscription_modify_monitored_items_req(service_mgr__session,
487
0
            service_mgr__req_msg,
488
0
            service_mgr__resp_msg,
489
0
            service_mgr__StatusCode_service);
490
0
         break;
491
0
      case constants__e_msg_monitored_items_delete_req:
492
0
         subscription_mgr__treat_subscription_delete_monitored_items_req(service_mgr__session,
493
0
            service_mgr__req_msg,
494
0
            service_mgr__resp_msg,
495
0
            service_mgr__StatusCode_service);
496
0
         break;
497
0
      case constants__e_msg_monitored_items_set_monitoring_mode_req:
498
0
         subscription_mgr__treat_subscription_set_monit_mode_monitored_items_req(service_mgr__session,
499
0
            service_mgr__req_msg,
500
0
            service_mgr__resp_msg,
501
0
            service_mgr__StatusCode_service);
502
0
         break;
503
0
      case constants__e_msg_method_call_req:
504
0
         session_mgr__get_session_user_server(service_mgr__session,
505
0
            &service_mgr__l_user);
506
0
         address_space_itf__treat_method_call_request(service_mgr__l_user,
507
0
            service_mgr__endpoint_config_idx,
508
0
            service_mgr__req_msg,
509
0
            service_mgr__resp_msg,
510
0
            service_mgr__StatusCode_service);
511
0
         break;
512
0
      case constants__e_msg_attribute_history_read_req:
513
0
         constants__is_ExternalHistoryRawReadServiceActive(&service_mgr__l_bres);
514
0
         if (service_mgr__l_bres == true) {
515
0
            session_mgr__get_session_user_server(service_mgr__session,
516
0
               &service_mgr__l_user);
517
0
            service_history_read__treat_history_read_request(service_mgr__req_msg,
518
0
               service_mgr__resp_msg,
519
0
               service_mgr__l_user,
520
0
               service_mgr__StatusCode_service);
521
0
         }
522
0
         else {
523
0
            *service_mgr__StatusCode_service = constants_statuscodes_bs__e_sc_bad_service_unsupported;
524
0
         }
525
0
         break;
526
0
      case constants__e_msg_node_add_nodes_req:
527
0
         constants__is_ClientNodeManagementActive(&service_mgr__l_bres);
528
0
         if (service_mgr__l_bres == true) {
529
0
            session_mgr__get_session_user_server(service_mgr__session,
530
0
               &service_mgr__l_user);
531
0
            address_space_itf__treat_add_nodes_request(service_mgr__l_user,
532
0
               service_mgr__req_msg,
533
0
               service_mgr__resp_msg,
534
0
               service_mgr__StatusCode_service);
535
0
            service_mgr__l_node_management_done = (*service_mgr__StatusCode_service == constants_statuscodes_bs__e_sc_ok);
536
0
         }
537
0
         else {
538
0
            *service_mgr__StatusCode_service = constants_statuscodes_bs__e_sc_bad_service_unsupported;
539
0
         }
540
0
         break;
541
0
      case constants__e_msg_node_delete_nodes_req:
542
0
         constants__is_ClientNodeManagementActive(&service_mgr__l_bres);
543
0
         if (service_mgr__l_bres == true) {
544
0
            session_mgr__get_session_user_server(service_mgr__session,
545
0
               &service_mgr__l_user);
546
0
            address_space_itf__treat_delete_nodes_request(service_mgr__l_user,
547
0
               service_mgr__req_msg,
548
0
               service_mgr__resp_msg,
549
0
               service_mgr__StatusCode_service);
550
0
            service_mgr__l_node_management_done = (*service_mgr__StatusCode_service == constants_statuscodes_bs__e_sc_ok);
551
0
         }
552
0
         else {
553
0
            *service_mgr__StatusCode_service = constants_statuscodes_bs__e_sc_bad_service_unsupported;
554
0
         }
555
0
         break;
556
0
      default:
557
0
         *service_mgr__StatusCode_service = constants_statuscodes_bs__e_sc_bad_service_unsupported;
558
0
         break;
559
0
      }
560
0
      if (service_mgr__l_node_management_done == true) {
561
0
         service_set_view__service_set_view_service_node_management_used();
562
0
      }
563
0
   }
564
0
}
565
566
void service_mgr__decode_and_treat_session_service_req(
567
   const constants__t_channel_i service_mgr__p_channel,
568
   const constants__t_msg_type_i service_mgr__p_req_typ,
569
   const constants__t_request_context_i service_mgr__p_req_context,
570
   const constants__t_byte_buffer_i service_mgr__p_msg_buffer,
571
   const constants__t_msg_header_i service_mgr__p_req_header,
572
   const constants__t_server_request_handle_i service_mgr__p_req_handle,
573
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__p_sc,
574
   t_bool * const service_mgr__p_valid_req,
575
   t_bool * const service_mgr__p_async,
576
   constants__t_msg_type_i * const service_mgr__p_resp_typ,
577
   constants__t_msg_header_i * const service_mgr__p_resp_header,
578
0
   constants__t_msg_i * const service_mgr__p_resp_msg) {
579
0
   {
580
0
      constants__t_session_token_i service_mgr__l_session_token;
581
0
      t_bool service_mgr__l_is_valid_req_on_session;
582
0
      constants__t_session_i service_mgr__l_session;
583
0
      constants__t_endpoint_config_idx_i service_mgr__l_endpoint_config_idx;
584
0
      t_bool service_mgr__l_is_valid_ep_config_idx;
585
0
      constants__t_msg_i service_mgr__l_req_msg;
586
0
      t_bool service_mgr__l_overwrite_req_msg;
587
0
      constants__t_msg_i service_mgr__l_new_req_msg;
588
0
      constants__t_msg_type_i service_mgr__l_new_req_type;
589
      
590
0
      *service_mgr__p_resp_typ = constants__c_msg_type_indet;
591
0
      *service_mgr__p_resp_header = constants__c_msg_header_indet;
592
0
      *service_mgr__p_resp_msg = constants__c_msg_indet;
593
0
      *service_mgr__p_async = false;
594
0
      message_in_bs__read_msg_req_header_session_token(service_mgr__p_req_header,
595
0
         &service_mgr__l_session_token);
596
0
      session_mgr__server_validate_session_service_req(service_mgr__p_channel,
597
0
         service_mgr__l_session_token,
598
0
         &service_mgr__l_is_valid_req_on_session,
599
0
         &service_mgr__l_session,
600
0
         service_mgr__p_sc);
601
0
      channel_mgr__server_get_endpoint_config(service_mgr__p_channel,
602
0
         &service_mgr__l_endpoint_config_idx);
603
0
      channel_mgr__is_valid_endpoint_config_idx(service_mgr__l_endpoint_config_idx,
604
0
         &service_mgr__l_is_valid_ep_config_idx);
605
0
      if ((service_mgr__l_is_valid_req_on_session == true) &&
606
0
         (service_mgr__l_is_valid_ep_config_idx == true)) {
607
0
         message_in_bs__decode_msg(service_mgr__p_req_typ,
608
0
            service_mgr__p_msg_buffer,
609
0
            service_mgr__p_valid_req,
610
0
            &service_mgr__l_req_msg);
611
0
         service_mgr__l_new_req_msg = service_mgr__l_req_msg;
612
0
         service_mgr__l_new_req_type = service_mgr__p_req_typ;
613
0
         if (*service_mgr__p_valid_req == true) {
614
0
            service_mgr__get_response_type(service_mgr__p_req_typ,
615
0
               service_mgr__p_resp_typ);
616
0
            message_out_bs__alloc_resp_msg(*service_mgr__p_resp_typ,
617
0
               service_mgr__p_resp_header,
618
0
               service_mgr__p_resp_msg);
619
0
            if (*service_mgr__p_resp_msg != constants__c_msg_indet) {
620
0
               app_overwrite_req_cb_bs__has_server_overwrite_req_cb(service_mgr__l_endpoint_config_idx,
621
0
                  &service_mgr__l_overwrite_req_msg);
622
0
               if (service_mgr__l_overwrite_req_msg == true) {
623
0
                  app_overwrite_req_cb_bs__overwrite_service_request(service_mgr__l_req_msg,
624
0
                     service_mgr__p_sc,
625
0
                     &service_mgr__l_new_req_msg);
626
0
                  message_in_bs__bless_msg_in(service_mgr__l_new_req_msg,
627
0
                     &service_mgr__l_new_req_type);
628
0
               }
629
0
               if (*service_mgr__p_sc == constants_statuscodes_bs__e_sc_ok) {
630
0
                  service_mgr__treat_session_service_req(service_mgr__l_endpoint_config_idx,
631
0
                     service_mgr__l_session,
632
0
                     service_mgr__l_new_req_type,
633
0
                     service_mgr__p_req_handle,
634
0
                     service_mgr__p_req_context,
635
0
                     service_mgr__p_req_header,
636
0
                     service_mgr__l_new_req_msg,
637
0
                     *service_mgr__p_resp_msg,
638
0
                     service_mgr__p_sc,
639
0
                     service_mgr__p_async);
640
0
               }
641
0
            }
642
0
            else {
643
0
               *service_mgr__p_sc = constants_statuscodes_bs__e_sc_bad_out_of_memory;
644
0
            }
645
0
            message_in_bs__dealloc_msg_in(service_mgr__l_new_req_msg);
646
0
         }
647
0
         else {
648
0
            *service_mgr__p_sc = constants_statuscodes_bs__e_sc_bad_decoding_error;
649
0
         }
650
0
      }
651
0
      else {
652
0
         *service_mgr__p_valid_req = true;
653
0
      }
654
0
   }
655
0
}
656
657
void service_mgr__treat_session_service_req(
658
   const constants__t_endpoint_config_idx_i service_mgr__endpoint_config_idx,
659
   const constants__t_session_i service_mgr__session,
660
   const constants__t_msg_type_i service_mgr__req_typ,
661
   const constants__t_server_request_handle_i service_mgr__req_handle,
662
   const constants__t_request_context_i service_mgr__req_ctx,
663
   const constants__t_msg_header_i service_mgr__req_header,
664
   const constants__t_msg_i service_mgr__req_msg,
665
   const constants__t_msg_i service_mgr__resp_msg,
666
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__StatusCode_service,
667
0
   t_bool * const service_mgr__async_resp_msg) {
668
0
   {
669
0
      constants__t_user_i service_mgr__l_user;
670
0
      constants__t_sessionRoles_i service_mgr__l_roles;
671
      
672
0
      *service_mgr__async_resp_msg = false;
673
0
      session_mgr__get_session_user_server(service_mgr__session,
674
0
         &service_mgr__l_user);
675
0
      session_mgr__get_session_roles(service_mgr__session,
676
0
         &service_mgr__l_roles);
677
0
      address_space_itf__set_user_roles(service_mgr__l_user,
678
0
         service_mgr__l_roles);
679
0
      if (constants__c_Server_Nano_Extended == true) {
680
0
         service_mgr__treat_session_nano_extended_service_req(service_mgr__endpoint_config_idx,
681
0
            service_mgr__session,
682
0
            service_mgr__req_typ,
683
0
            service_mgr__req_handle,
684
0
            service_mgr__req_ctx,
685
0
            service_mgr__req_header,
686
0
            service_mgr__req_msg,
687
0
            service_mgr__resp_msg,
688
0
            service_mgr__StatusCode_service,
689
0
            service_mgr__async_resp_msg);
690
0
      }
691
0
      else {
692
0
         service_mgr__treat_session_nano_service_req(service_mgr__endpoint_config_idx,
693
0
            service_mgr__session,
694
0
            service_mgr__req_typ,
695
0
            service_mgr__req_msg,
696
0
            service_mgr__resp_msg,
697
0
            service_mgr__StatusCode_service);
698
0
      }
699
0
      address_space_itf__clear_user_roles();
700
0
   }
701
0
}
702
703
void service_mgr__encode_session_service_resp(
704
   const constants__t_server_request_handle_i service_mgr__p_request_handle,
705
   const constants__t_channel_i service_mgr__p_channel,
706
   const constants_statuscodes_bs__t_StatusCode_i service_mgr__p_msg_sc,
707
   const constants__t_msg_type_i service_mgr__p_msg_type,
708
   const constants__t_msg_header_i service_mgr__p_msg_header,
709
   const constants__t_msg_i service_mgr__p_msg,
710
   const t_bool service_mgr__p_async,
711
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__p_sc,
712
0
   constants__t_byte_buffer_i * const service_mgr__p_buffer_out) {
713
0
   {
714
0
      constants__t_msg_type_i service_mgr__l_msg_type;
715
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
716
      
717
0
      *service_mgr__p_sc = constants_statuscodes_bs__c_StatusCode_indet;
718
0
      *service_mgr__p_buffer_out = constants__c_byte_buffer_indet;
719
0
      if (service_mgr__p_async == false) {
720
0
         if (service_mgr__p_msg_sc == constants_statuscodes_bs__e_sc_ok) {
721
0
            service_mgr__l_msg_type = service_mgr__p_msg_type;
722
0
         }
723
0
         else {
724
0
            service_mgr__l_msg_type = constants__e_msg_service_fault_resp;
725
0
         }
726
0
         message_out_bs__server_write_msg_out_header_req_handle(service_mgr__p_msg_header,
727
0
            service_mgr__p_request_handle);
728
0
         message_out_bs__write_msg_resp_header_service_status(service_mgr__p_msg_header,
729
0
            service_mgr__p_msg_sc);
730
0
         channel_mgr__get_channel_info(service_mgr__p_channel,
731
0
            &service_mgr__l_channel_cfg);
732
0
         message_out_bs__encode_msg(service_mgr__l_channel_cfg,
733
0
            constants__e_msg_response_type,
734
0
            service_mgr__l_msg_type,
735
0
            service_mgr__p_msg_header,
736
0
            service_mgr__p_msg,
737
0
            service_mgr__p_sc,
738
0
            service_mgr__p_buffer_out);
739
0
         message_out_bs__dealloc_msg_header_out(service_mgr__p_msg_header);
740
0
         message_out_bs__dealloc_msg_out(service_mgr__p_msg);
741
0
      }
742
0
      else {
743
0
         message_out_bs__dealloc_msg_header_out(service_mgr__p_msg_header);
744
0
         message_out_bs__forget_msg_out(service_mgr__p_msg);
745
0
      }
746
0
   }
747
0
}
748
749
void service_mgr__alloc_and_encode_session_service_fault_resp(
750
   const constants__t_server_request_handle_i service_mgr__p_request_handle,
751
   const constants__t_channel_i service_mgr__p_channel,
752
   const constants_statuscodes_bs__t_StatusCode_i service_mgr__p_msg_sc,
753
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__p_sc,
754
0
   constants__t_byte_buffer_i * const service_mgr__p_buffer_out) {
755
0
   {
756
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
757
0
      constants__t_msg_i service_mgr__l_resp_msg;
758
0
      constants__t_msg_type_i service_mgr__l_resp_msg_typ;
759
      
760
0
      *service_mgr__p_buffer_out = constants__c_byte_buffer_indet;
761
0
      service_mgr__l_resp_msg_typ = constants__e_msg_service_fault_resp;
762
0
      message_out_bs__alloc_resp_msg(service_mgr__l_resp_msg_typ,
763
0
         &service_mgr__l_resp_msg_header,
764
0
         &service_mgr__l_resp_msg);
765
0
      if (service_mgr__l_resp_msg != constants__c_msg_indet) {
766
0
         service_mgr__encode_session_service_resp(service_mgr__p_request_handle,
767
0
            service_mgr__p_channel,
768
0
            service_mgr__p_msg_sc,
769
0
            service_mgr__l_resp_msg_typ,
770
0
            service_mgr__l_resp_msg_header,
771
0
            service_mgr__l_resp_msg,
772
0
            false,
773
0
            service_mgr__p_sc,
774
0
            service_mgr__p_buffer_out);
775
0
      }
776
0
      else {
777
0
         *service_mgr__p_sc = constants_statuscodes_bs__e_sc_bad_out_of_memory;
778
0
      }
779
0
   }
780
0
}
781
782
void service_mgr__treat_discovery_service_req(
783
   const constants__t_endpoint_config_idx_i service_mgr__endpoint_config_idx,
784
   const constants__t_msg_type_i service_mgr__req_typ,
785
   const constants__t_msg_i service_mgr__req_msg,
786
   const constants__t_msg_i service_mgr__resp_msg,
787
0
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__StatusCode_service) {
788
0
   {
789
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
790
0
      constants__t_ApplicationDescription_i service_mgr__l_app_desc;
791
0
      t_bool service_mgr__l_is_discovery_server;
792
      
793
0
      service_set_discovery_server__get_ApplicationDescription(service_mgr__endpoint_config_idx,
794
0
         &service_mgr__l_app_desc);
795
0
      service_set_discovery_server__is_ApplicationDescription_DiscoveryServerType(service_mgr__l_app_desc,
796
0
         &service_mgr__l_is_discovery_server);
797
0
      switch (service_mgr__req_typ) {
798
0
      case constants__e_msg_discovery_get_endpoints_req:
799
0
         service_get_endpoints_bs__treat_get_endpoints_request(service_mgr__req_msg,
800
0
            service_mgr__resp_msg,
801
0
            service_mgr__endpoint_config_idx,
802
0
            &service_mgr__l_ret);
803
0
         break;
804
0
      case constants__e_msg_discovery_find_servers_req:
805
0
         service_set_discovery_server__treat_find_servers_request(service_mgr__req_msg,
806
0
            service_mgr__resp_msg,
807
0
            service_mgr__endpoint_config_idx,
808
0
            &service_mgr__l_ret);
809
0
         break;
810
0
      default:
811
0
         if (service_mgr__l_is_discovery_server == true) {
812
0
            switch (service_mgr__req_typ) {
813
0
            case constants__e_msg_discovery_find_servers_on_network_req:
814
0
               service_set_discovery_server__treat_find_servers_on_network_request(service_mgr__req_msg,
815
0
                  service_mgr__resp_msg,
816
0
                  &service_mgr__l_ret);
817
0
               break;
818
0
            case constants__e_msg_discovery_register_server2_req:
819
0
               service_set_discovery_server__treat_register_server2_request(service_mgr__req_msg,
820
0
                  service_mgr__resp_msg,
821
0
                  &service_mgr__l_ret);
822
0
               break;
823
0
            default:
824
0
               service_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
825
0
               break;
826
0
            }
827
0
         }
828
0
         else {
829
0
            service_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
830
0
         }
831
0
         break;
832
0
      }
833
0
      *service_mgr__StatusCode_service = service_mgr__l_ret;
834
0
   }
835
0
}
836
837
void service_mgr__local_client_discovery_service_request(
838
   const constants__t_channel_i service_mgr__channel,
839
   const constants__t_msg_type_i service_mgr__req_typ,
840
   const constants__t_msg_i service_mgr__req_msg,
841
   const constants__t_application_context_i service_mgr__app_context,
842
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__ret,
843
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
844
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
845
0
   {
846
0
      constants__t_msg_header_i service_mgr__l_msg_header;
847
0
      constants__t_msg_type_i service_mgr__l_resp_typ;
848
0
      constants__t_client_request_handle_i service_mgr__l_req_handle;
849
0
      t_bool service_mgr__l_valid_req_handle;
850
0
      constants__t_byte_buffer_i service_mgr__l_buffer;
851
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
852
      
853
0
      service_mgr__l_buffer = constants__c_byte_buffer_indet;
854
0
      service_mgr__l_req_handle = constants__c_client_request_handle_indet;
855
0
      switch (service_mgr__req_typ) {
856
0
      case constants__e_msg_discovery_find_servers_req:
857
0
      case constants__e_msg_discovery_find_servers_on_network_req:
858
0
      case constants__e_msg_discovery_get_endpoints_req:
859
0
      case constants__e_msg_discovery_register_server_req:
860
0
      case constants__e_msg_discovery_register_server2_req:
861
0
         service_mgr__get_response_type(service_mgr__req_typ,
862
0
            &service_mgr__l_resp_typ);
863
0
         message_out_bs__alloc_msg_header(true,
864
0
            &service_mgr__l_msg_header);
865
0
         request_handle_bs__client_fresh_req_handle(service_mgr__req_typ,
866
0
            service_mgr__l_resp_typ,
867
0
            true,
868
0
            service_mgr__app_context,
869
0
            &service_mgr__l_req_handle);
870
0
         request_handle_bs__is_valid_req_handle(service_mgr__l_req_handle,
871
0
            &service_mgr__l_valid_req_handle);
872
0
         if ((service_mgr__l_valid_req_handle == true) &&
873
0
            (service_mgr__l_msg_header != constants__c_msg_header_indet)) {
874
0
            request_handle_bs__set_req_handle_channel(service_mgr__l_req_handle,
875
0
               service_mgr__channel);
876
0
            message_out_bs__client_write_msg_out_header_req_handle(service_mgr__l_msg_header,
877
0
               service_mgr__l_req_handle);
878
0
            channel_mgr__get_channel_info(service_mgr__channel,
879
0
               &service_mgr__l_channel_cfg);
880
0
            message_out_bs__encode_msg(service_mgr__l_channel_cfg,
881
0
               constants__e_msg_request_type,
882
0
               service_mgr__req_typ,
883
0
               service_mgr__l_msg_header,
884
0
               service_mgr__req_msg,
885
0
               service_mgr__ret,
886
0
               &service_mgr__l_buffer);
887
0
            if (*service_mgr__ret != constants_statuscodes_bs__e_sc_ok) {
888
0
               service_mgr__l_req_handle = constants__c_client_request_handle_indet;
889
0
            }
890
0
         }
891
0
         else {
892
0
            service_mgr__l_req_handle = constants__c_client_request_handle_indet;
893
0
            *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
894
0
         }
895
0
         if (service_mgr__l_msg_header != constants__c_msg_header_indet) {
896
0
            message_out_bs__dealloc_msg_header_out(service_mgr__l_msg_header);
897
0
         }
898
0
         break;
899
0
      default:
900
0
         *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
901
0
         break;
902
0
      }
903
0
      *service_mgr__buffer_out = service_mgr__l_buffer;
904
0
      *service_mgr__req_handle = service_mgr__l_req_handle;
905
0
   }
906
0
}
907
908
void service_mgr__l_client_snd_msg_failure(
909
   const constants__t_channel_i service_mgr__channel,
910
   const constants__t_client_request_handle_i service_mgr__request_handle,
911
0
   const constants_statuscodes_bs__t_StatusCode_i service_mgr__error_status) {
912
0
   {
913
0
      t_bool service_mgr__l_valid_req_handle;
914
0
      constants__t_channel_i service_mgr__l_req_handle_channel;
915
0
      constants__t_msg_type_i service_mgr__l_req_typ;
916
0
      t_bool service_mgr__l_is_applicative;
917
0
      constants__t_application_context_i service_mgr__l_app_context;
918
0
      constants__t_msg_type_i service_mgr__l_exp_resp_msg_typ;
919
0
      constants__t_msg_service_class_i service_mgr__l_exp_resp_msg_class;
920
0
      t_bool service_mgr__l_trigger_app_treatment;
921
0
      t_bool service_mgr__l_bres;
922
0
      constants__t_session_i service_mgr__l_session;
923
      
924
0
      service_mgr__l_trigger_app_treatment = false;
925
0
      request_handle_bs__is_valid_req_handle(service_mgr__request_handle,
926
0
         &service_mgr__l_valid_req_handle);
927
0
      request_handle_bs__get_req_handle_channel(service_mgr__request_handle,
928
0
         &service_mgr__l_req_handle_channel);
929
0
      if ((service_mgr__l_valid_req_handle == true) &&
930
0
         (service_mgr__l_req_handle_channel == service_mgr__channel)) {
931
0
         request_handle_bs__get_req_handle_resp_typ(service_mgr__request_handle,
932
0
            &service_mgr__l_exp_resp_msg_typ);
933
0
         service_mgr__l_get_msg_service_class(service_mgr__l_exp_resp_msg_typ,
934
0
            &service_mgr__l_exp_resp_msg_class);
935
0
         switch (service_mgr__l_exp_resp_msg_class) {
936
0
         case constants__e_msg_session_treatment_class:
937
0
            session_mgr__client_validate_session_service_resp(service_mgr__channel,
938
0
               service_mgr__request_handle,
939
0
               &service_mgr__l_bres,
940
0
               &service_mgr__l_session);
941
0
            if (service_mgr__l_bres == true) {
942
0
               session_mgr__client_close_session(service_mgr__l_session,
943
0
                  constants_statuscodes_bs__e_sc_bad_request_interrupted);
944
0
            }
945
0
            break;
946
0
         case constants__e_msg_session_service_class:
947
0
            session_mgr__client_validate_session_service_req_failed(service_mgr__channel,
948
0
               service_mgr__request_handle,
949
0
               &service_mgr__l_trigger_app_treatment);
950
0
            break;
951
0
         case constants__e_msg_discovery_service_class:
952
0
            service_mgr__l_trigger_app_treatment = true;
953
0
            break;
954
0
         default:
955
0
            service_mgr__l_trigger_app_treatment = false;
956
0
            break;
957
0
         }
958
0
         if (service_mgr__l_trigger_app_treatment == true) {
959
0
            request_handle_bs__get_req_handle_app_context(service_mgr__request_handle,
960
0
               &service_mgr__l_is_applicative,
961
0
               &service_mgr__l_app_context);
962
0
            request_handle_bs__get_req_handle_req_typ(service_mgr__request_handle,
963
0
               &service_mgr__l_req_typ);
964
0
            if (service_mgr__l_is_applicative == true) {
965
0
               service_response_cb_bs__cli_snd_failure(service_mgr__l_req_typ,
966
0
                  service_mgr__l_app_context,
967
0
                  service_mgr__error_status);
968
0
            }
969
0
         }
970
0
         request_handle_bs__client_remove_req_handle(service_mgr__request_handle);
971
0
      }
972
0
   }
973
0
}
974
975
void service_mgr__client_service_fault_to_resp_type(
976
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
977
   t_bool * const service_mgr__valid,
978
0
   constants__t_msg_type_i * const service_mgr__resp_typ) {
979
0
   {
980
0
      constants__t_client_request_handle_i service_mgr__l_request_handle;
981
      
982
0
      message_in_bs__decode_service_fault_msg_req_handle(service_mgr__msg_buffer,
983
0
         &service_mgr__l_request_handle);
984
0
      request_handle_bs__is_valid_req_handle(service_mgr__l_request_handle,
985
0
         service_mgr__valid);
986
0
      if (*service_mgr__valid == true) {
987
0
         request_handle_bs__get_req_handle_resp_typ(service_mgr__l_request_handle,
988
0
            service_mgr__resp_typ);
989
0
      }
990
0
      else {
991
0
         *service_mgr__resp_typ = constants__c_msg_type_indet;
992
0
      }
993
0
   }
994
0
}
995
996
void service_mgr__server_receive_session_treatment_req(
997
   const constants__t_channel_i service_mgr__channel,
998
   const constants__t_msg_type_i service_mgr__req_typ,
999
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
1000
   t_bool * const service_mgr__valid_req_header,
1001
   t_bool * const service_mgr__valid_req,
1002
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__sc,
1003
0
   constants__t_byte_buffer_i * const service_mgr__buffer_out) {
1004
0
   {
1005
0
      constants__t_msg_header_i service_mgr__l_req_msg_header;
1006
0
      constants__t_msg_i service_mgr__l_req_msg;
1007
0
      constants__t_channel_config_idx_i service_mgr__l_channel_config_idx;
1008
0
      constants__t_server_request_handle_i service_mgr__l_request_handle;
1009
0
      constants__t_session_token_i service_mgr__l_session_token;
1010
0
      constants__t_msg_type_i service_mgr__l_resp_msg_typ;
1011
0
      constants__t_msg_i service_mgr__l_resp_msg;
1012
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1013
0
      constants__t_session_i service_mgr__l_session;
1014
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1015
0
      t_bool service_mgr__l_secu_failed;
1016
0
      constants__t_byte_buffer_i service_mgr__l_buffer_out;
1017
      
1018
0
      *service_mgr__valid_req = false;
1019
0
      *service_mgr__sc = constants_statuscodes_bs__e_sc_bad_decoding_error;
1020
0
      service_mgr__l_buffer_out = constants__c_byte_buffer_indet;
1021
0
      message_in_bs__decode_msg_header(true,
1022
0
         service_mgr__msg_buffer,
1023
0
         service_mgr__valid_req_header,
1024
0
         &service_mgr__l_req_msg_header);
1025
0
      if (*service_mgr__valid_req_header == true) {
1026
0
         channel_mgr__get_channel_info(service_mgr__channel,
1027
0
            &service_mgr__l_channel_config_idx);
1028
0
         session_mgr__set_request_audit_info(service_mgr__l_channel_config_idx,
1029
0
            service_mgr__l_req_msg_header);
1030
0
         message_in_bs__server_read_msg_header_req_handle(service_mgr__l_req_msg_header,
1031
0
            &service_mgr__l_request_handle);
1032
0
         message_in_bs__read_msg_req_header_session_token(service_mgr__l_req_msg_header,
1033
0
            &service_mgr__l_session_token);
1034
0
         message_in_bs__decode_msg(service_mgr__req_typ,
1035
0
            service_mgr__msg_buffer,
1036
0
            service_mgr__valid_req,
1037
0
            &service_mgr__l_req_msg);
1038
0
         if (*service_mgr__valid_req == true) {
1039
0
            service_mgr__get_response_type(service_mgr__req_typ,
1040
0
               &service_mgr__l_resp_msg_typ);
1041
0
            message_out_bs__alloc_resp_msg(service_mgr__l_resp_msg_typ,
1042
0
               &service_mgr__l_resp_msg_header,
1043
0
               &service_mgr__l_resp_msg);
1044
0
            if (service_mgr__l_resp_msg != constants__c_msg_indet) {
1045
0
               session_mgr__server_receive_session_req(service_mgr__channel,
1046
0
                  service_mgr__l_session_token,
1047
0
                  service_mgr__l_req_msg,
1048
0
                  service_mgr__req_typ,
1049
0
                  service_mgr__l_resp_msg,
1050
0
                  &service_mgr__l_session,
1051
0
                  &service_mgr__l_ret,
1052
0
                  &service_mgr__l_secu_failed);
1053
0
               if (service_mgr__l_ret != constants_statuscodes_bs__e_sc_ok) {
1054
0
                  service_mgr__l_resp_msg_typ = constants__e_msg_service_fault_resp;
1055
0
               }
1056
0
               service_mgr__encode_session_service_resp(service_mgr__l_request_handle,
1057
0
                  service_mgr__channel,
1058
0
                  service_mgr__l_ret,
1059
0
                  service_mgr__l_resp_msg_typ,
1060
0
                  service_mgr__l_resp_msg_header,
1061
0
                  service_mgr__l_resp_msg,
1062
0
                  false,
1063
0
                  service_mgr__sc,
1064
0
                  &service_mgr__l_buffer_out);
1065
0
               if (*service_mgr__sc != constants_statuscodes_bs__e_sc_ok) {
1066
0
                  session_mgr__server_close_session(service_mgr__l_session,
1067
0
                     constants_statuscodes_bs__e_sc_bad_encoding_error);
1068
0
               }
1069
0
               if (service_mgr__l_secu_failed == true) {
1070
0
                  *service_mgr__sc = constants_statuscodes_bs__e_sc_bad_security_checks_failed;
1071
0
               }
1072
0
            }
1073
0
            else {
1074
0
               *service_mgr__sc = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1075
0
            }
1076
0
            message_in_bs__dealloc_msg_in(service_mgr__l_req_msg);
1077
0
         }
1078
0
         else {
1079
0
            service_mgr__alloc_and_encode_session_service_fault_resp(service_mgr__l_request_handle,
1080
0
               service_mgr__channel,
1081
0
               constants_statuscodes_bs__e_sc_bad_decoding_error,
1082
0
               service_mgr__sc,
1083
0
               &service_mgr__l_buffer_out);
1084
0
         }
1085
0
         session_mgr__clear_audit_info();
1086
0
         message_in_bs__dealloc_msg_in_header(service_mgr__l_req_msg_header);
1087
0
      }
1088
0
      *service_mgr__buffer_out = service_mgr__l_buffer_out;
1089
0
   }
1090
0
}
1091
1092
void service_mgr__client_receive_session_treatment_resp(
1093
   const constants__t_channel_i service_mgr__channel,
1094
   const constants__t_msg_type_i service_mgr__resp_typ,
1095
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
1096
0
   t_bool * const service_mgr__valid_resp) {
1097
0
   {
1098
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1099
0
      t_bool service_mgr__l_valid_resp_header;
1100
0
      constants__t_msg_i service_mgr__l_resp_msg;
1101
0
      constants__t_client_request_handle_i service_mgr__l_request_handle;
1102
0
      t_bool service_mgr__l_validated_req_handle;
1103
0
      constants__t_session_i service_mgr__l_session;
1104
      
1105
0
      *service_mgr__valid_resp = false;
1106
0
      message_in_bs__decode_msg_header(false,
1107
0
         service_mgr__msg_buffer,
1108
0
         &service_mgr__l_valid_resp_header,
1109
0
         &service_mgr__l_resp_msg_header);
1110
0
      if (service_mgr__l_valid_resp_header == true) {
1111
0
         message_in_bs__client_read_msg_header_req_handle(service_mgr__l_resp_msg_header,
1112
0
            &service_mgr__l_request_handle);
1113
0
         request_handle_bs__client_validate_response_request_handle(service_mgr__channel,
1114
0
            service_mgr__l_request_handle,
1115
0
            service_mgr__resp_typ,
1116
0
            &service_mgr__l_validated_req_handle);
1117
0
         if (service_mgr__l_validated_req_handle == true) {
1118
0
            message_in_bs__decode_msg(service_mgr__resp_typ,
1119
0
               service_mgr__msg_buffer,
1120
0
               service_mgr__valid_resp,
1121
0
               &service_mgr__l_resp_msg);
1122
0
            if (*service_mgr__valid_resp == true) {
1123
0
               session_mgr__client_receive_session_resp(service_mgr__channel,
1124
0
                  service_mgr__l_request_handle,
1125
0
                  service_mgr__resp_typ,
1126
0
                  service_mgr__l_resp_msg_header,
1127
0
                  service_mgr__l_resp_msg,
1128
0
                  &service_mgr__l_session);
1129
0
               message_in_bs__dealloc_msg_in(service_mgr__l_resp_msg);
1130
0
            }
1131
0
            else {
1132
0
               session_mgr__client_receive_session_resp_decode_failed(service_mgr__l_request_handle);
1133
0
            }
1134
0
            request_handle_bs__client_remove_req_handle(service_mgr__l_request_handle);
1135
0
         }
1136
0
         message_in_bs__dealloc_msg_in_header(service_mgr__l_resp_msg_header);
1137
0
      }
1138
0
   }
1139
0
}
1140
1141
void service_mgr__server_receive_session_service_req(
1142
   const constants__t_channel_i service_mgr__channel,
1143
   const constants__t_msg_type_i service_mgr__req_typ,
1144
   const constants__t_request_context_i service_mgr__req_context,
1145
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
1146
   t_bool * const service_mgr__valid_req_header,
1147
   t_bool * const service_mgr__valid_req,
1148
   t_bool * const service_mgr__async_resp,
1149
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__sc,
1150
0
   constants__t_byte_buffer_i * const service_mgr__buffer_out) {
1151
0
   {
1152
0
      constants__t_msg_header_i service_mgr__l_req_msg_header;
1153
0
      constants__t_server_request_handle_i service_mgr__l_request_handle;
1154
0
      constants__t_msg_type_i service_mgr__l_resp_msg_typ;
1155
0
      constants__t_msg_i service_mgr__l_resp_msg;
1156
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1157
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1158
      
1159
0
      *service_mgr__sc = constants_statuscodes_bs__c_StatusCode_indet;
1160
0
      *service_mgr__valid_req = false;
1161
0
      service_mgr__l_resp_msg_typ = constants__c_msg_type_indet;
1162
0
      service_mgr__l_resp_msg_header = constants__c_msg_header_indet;
1163
0
      service_mgr__l_resp_msg = constants__c_msg_indet;
1164
0
      *service_mgr__async_resp = false;
1165
0
      *service_mgr__buffer_out = constants__c_byte_buffer_indet;
1166
0
      message_in_bs__decode_msg_header(true,
1167
0
         service_mgr__msg_buffer,
1168
0
         service_mgr__valid_req_header,
1169
0
         &service_mgr__l_req_msg_header);
1170
0
      if (*service_mgr__valid_req_header == true) {
1171
0
         message_in_bs__server_read_msg_header_req_handle(service_mgr__l_req_msg_header,
1172
0
            &service_mgr__l_request_handle);
1173
0
         service_mgr__decode_and_treat_session_service_req(service_mgr__channel,
1174
0
            service_mgr__req_typ,
1175
0
            service_mgr__req_context,
1176
0
            service_mgr__msg_buffer,
1177
0
            service_mgr__l_req_msg_header,
1178
0
            service_mgr__l_request_handle,
1179
0
            &service_mgr__l_ret,
1180
0
            service_mgr__valid_req,
1181
0
            service_mgr__async_resp,
1182
0
            &service_mgr__l_resp_msg_typ,
1183
0
            &service_mgr__l_resp_msg_header,
1184
0
            &service_mgr__l_resp_msg);
1185
0
         if (service_mgr__l_resp_msg != constants__c_msg_indet) {
1186
0
            service_mgr__encode_session_service_resp(service_mgr__l_request_handle,
1187
0
               service_mgr__channel,
1188
0
               service_mgr__l_ret,
1189
0
               service_mgr__l_resp_msg_typ,
1190
0
               service_mgr__l_resp_msg_header,
1191
0
               service_mgr__l_resp_msg,
1192
0
               *service_mgr__async_resp,
1193
0
               service_mgr__sc,
1194
0
               service_mgr__buffer_out);
1195
0
         }
1196
0
         else {
1197
0
            service_mgr__alloc_and_encode_session_service_fault_resp(service_mgr__l_request_handle,
1198
0
               service_mgr__channel,
1199
0
               service_mgr__l_ret,
1200
0
               service_mgr__sc,
1201
0
               service_mgr__buffer_out);
1202
0
         }
1203
0
         message_in_bs__dealloc_msg_in_header(service_mgr__l_req_msg_header);
1204
0
      }
1205
0
   }
1206
0
}
1207
1208
void service_mgr__client_receive_session_service_resp(
1209
   const constants__t_channel_i service_mgr__channel,
1210
   const constants__t_msg_type_i service_mgr__resp_typ,
1211
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
1212
0
   t_bool * const service_mgr__valid_resp) {
1213
0
   {
1214
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1215
0
      t_bool service_mgr__l_valid_resp_header;
1216
0
      constants__t_client_request_handle_i service_mgr__l_request_handle;
1217
0
      t_bool service_mgr__l_validated_req_handle;
1218
0
      constants__t_application_context_i service_mgr__l_user_app_context;
1219
0
      t_bool service_mgr__l_is_applicative_response;
1220
0
      t_bool service_mgr__l_is_valid_session_resp;
1221
0
      constants__t_session_i service_mgr__l_session;
1222
0
      constants__t_msg_i service_mgr__l_resp_msg;
1223
0
      constants__t_msg_type_i service_mgr__l_req_typ;
1224
      
1225
0
      *service_mgr__valid_resp = false;
1226
0
      message_in_bs__decode_msg_header(false,
1227
0
         service_mgr__msg_buffer,
1228
0
         &service_mgr__l_valid_resp_header,
1229
0
         &service_mgr__l_resp_msg_header);
1230
0
      if (service_mgr__l_valid_resp_header == true) {
1231
0
         message_in_bs__client_read_msg_header_req_handle(service_mgr__l_resp_msg_header,
1232
0
            &service_mgr__l_request_handle);
1233
0
         request_handle_bs__client_validate_response_request_handle(service_mgr__channel,
1234
0
            service_mgr__l_request_handle,
1235
0
            service_mgr__resp_typ,
1236
0
            &service_mgr__l_validated_req_handle);
1237
0
         if (service_mgr__l_validated_req_handle == true) {
1238
0
            request_handle_bs__get_req_handle_app_context(service_mgr__l_request_handle,
1239
0
               &service_mgr__l_is_applicative_response,
1240
0
               &service_mgr__l_user_app_context);
1241
0
            session_mgr__client_validate_session_service_resp(service_mgr__channel,
1242
0
               service_mgr__l_request_handle,
1243
0
               &service_mgr__l_is_valid_session_resp,
1244
0
               &service_mgr__l_session);
1245
0
            if (service_mgr__l_is_valid_session_resp == true) {
1246
0
               message_in_bs__decode_msg(service_mgr__resp_typ,
1247
0
                  service_mgr__msg_buffer,
1248
0
                  service_mgr__valid_resp,
1249
0
                  &service_mgr__l_resp_msg);
1250
0
               if (service_mgr__l_is_applicative_response == true) {
1251
0
                  if (*service_mgr__valid_resp == true) {
1252
0
                     message_in_bs__copy_msg_resp_header_into_msg(service_mgr__l_resp_msg_header,
1253
0
                        service_mgr__l_resp_msg);
1254
0
                     service_response_cb_bs__cli_service_response(service_mgr__l_session,
1255
0
                        service_mgr__l_resp_msg,
1256
0
                        service_mgr__l_user_app_context);
1257
0
                     message_in_bs__forget_msg_in(service_mgr__l_resp_msg);
1258
0
                  }
1259
0
                  else {
1260
0
                     request_handle_bs__get_req_handle_req_typ(service_mgr__l_request_handle,
1261
0
                        &service_mgr__l_req_typ);
1262
0
                     service_response_cb_bs__cli_snd_failure(service_mgr__l_req_typ,
1263
0
                        service_mgr__l_user_app_context,
1264
0
                        constants_statuscodes_bs__e_sc_bad_decoding_error);
1265
0
                  }
1266
0
               }
1267
0
            }
1268
0
            request_handle_bs__client_remove_req_handle(service_mgr__l_request_handle);
1269
0
         }
1270
0
         message_in_bs__dealloc_msg_in_header(service_mgr__l_resp_msg_header);
1271
0
      }
1272
0
   }
1273
0
}
1274
1275
void service_mgr__server_receive_discovery_service_req(
1276
   const constants__t_channel_i service_mgr__channel,
1277
   const constants__t_msg_type_i service_mgr__req_typ,
1278
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
1279
   t_bool * const service_mgr__valid_req_header,
1280
   t_bool * const service_mgr__valid_req,
1281
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__sc,
1282
0
   constants__t_byte_buffer_i * const service_mgr__buffer_out) {
1283
0
   {
1284
0
      constants__t_msg_header_i service_mgr__l_req_msg_header;
1285
0
      constants__t_server_request_handle_i service_mgr__l_request_handle;
1286
0
      constants__t_msg_i service_mgr__l_req_msg;
1287
0
      constants__t_msg_type_i service_mgr__l_resp_msg_typ;
1288
0
      constants__t_msg_i service_mgr__l_resp_msg;
1289
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1290
0
      constants__t_endpoint_config_idx_i service_mgr__l_endpoint_config_idx;
1291
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1292
0
      constants__t_byte_buffer_i service_mgr__l_buffer_out;
1293
      
1294
0
      *service_mgr__sc = constants_statuscodes_bs__c_StatusCode_indet;
1295
0
      *service_mgr__valid_req = false;
1296
0
      service_mgr__l_buffer_out = constants__c_byte_buffer_indet;
1297
0
      message_in_bs__decode_msg_header(true,
1298
0
         service_mgr__msg_buffer,
1299
0
         service_mgr__valid_req_header,
1300
0
         &service_mgr__l_req_msg_header);
1301
0
      if (*service_mgr__valid_req_header == true) {
1302
0
         message_in_bs__server_read_msg_header_req_handle(service_mgr__l_req_msg_header,
1303
0
            &service_mgr__l_request_handle);
1304
0
         message_in_bs__decode_msg(service_mgr__req_typ,
1305
0
            service_mgr__msg_buffer,
1306
0
            service_mgr__valid_req,
1307
0
            &service_mgr__l_req_msg);
1308
0
         if (*service_mgr__valid_req == true) {
1309
0
            service_mgr__get_response_type(service_mgr__req_typ,
1310
0
               &service_mgr__l_resp_msg_typ);
1311
0
            message_out_bs__alloc_resp_msg(service_mgr__l_resp_msg_typ,
1312
0
               &service_mgr__l_resp_msg_header,
1313
0
               &service_mgr__l_resp_msg);
1314
0
            if (service_mgr__l_resp_msg != constants__c_msg_indet) {
1315
0
               channel_mgr__server_get_endpoint_config(service_mgr__channel,
1316
0
                  &service_mgr__l_endpoint_config_idx);
1317
0
               service_mgr__treat_discovery_service_req(service_mgr__l_endpoint_config_idx,
1318
0
                  service_mgr__req_typ,
1319
0
                  service_mgr__l_req_msg,
1320
0
                  service_mgr__l_resp_msg,
1321
0
                  &service_mgr__l_ret);
1322
0
               message_out_bs__write_msg_resp_header_service_status(service_mgr__l_resp_msg_header,
1323
0
                  service_mgr__l_ret);
1324
0
               if (service_mgr__l_ret != constants_statuscodes_bs__e_sc_ok) {
1325
0
                  service_mgr__l_resp_msg_typ = constants__e_msg_service_fault_resp;
1326
0
               }
1327
0
               service_mgr__encode_session_service_resp(service_mgr__l_request_handle,
1328
0
                  service_mgr__channel,
1329
0
                  service_mgr__l_ret,
1330
0
                  service_mgr__l_resp_msg_typ,
1331
0
                  service_mgr__l_resp_msg_header,
1332
0
                  service_mgr__l_resp_msg,
1333
0
                  false,
1334
0
                  service_mgr__sc,
1335
0
                  &service_mgr__l_buffer_out);
1336
0
            }
1337
0
            else {
1338
0
               *service_mgr__sc = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1339
0
            }
1340
0
            message_in_bs__dealloc_msg_in(service_mgr__l_req_msg);
1341
0
         }
1342
0
         else {
1343
0
            service_mgr__alloc_and_encode_session_service_fault_resp(service_mgr__l_request_handle,
1344
0
               service_mgr__channel,
1345
0
               constants_statuscodes_bs__e_sc_bad_decoding_error,
1346
0
               service_mgr__sc,
1347
0
               &service_mgr__l_buffer_out);
1348
0
         }
1349
0
         message_in_bs__dealloc_msg_in_header(service_mgr__l_req_msg_header);
1350
0
      }
1351
0
      *service_mgr__buffer_out = service_mgr__l_buffer_out;
1352
0
   }
1353
0
}
1354
1355
void service_mgr__client_receive_discovery_service_resp(
1356
   const constants__t_channel_i service_mgr__channel,
1357
   const constants__t_msg_type_i service_mgr__resp_typ,
1358
   const constants__t_byte_buffer_i service_mgr__msg_buffer,
1359
0
   t_bool * const service_mgr__valid_resp) {
1360
0
   {
1361
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1362
0
      t_bool service_mgr__l_valid_resp_header;
1363
0
      constants__t_client_request_handle_i service_mgr__l_request_handle;
1364
0
      t_bool service_mgr__l_validated_req_handle;
1365
0
      t_bool service_mgr__l_is_applicative_response;
1366
0
      constants__t_application_context_i service_mgr__l_user_app_context;
1367
0
      constants__t_msg_i service_mgr__l_resp_msg;
1368
0
      constants__t_msg_type_i service_mgr__l_req_typ;
1369
      
1370
0
      *service_mgr__valid_resp = false;
1371
0
      message_in_bs__decode_msg_header(false,
1372
0
         service_mgr__msg_buffer,
1373
0
         &service_mgr__l_valid_resp_header,
1374
0
         &service_mgr__l_resp_msg_header);
1375
0
      if (service_mgr__l_valid_resp_header == true) {
1376
0
         message_in_bs__client_read_msg_header_req_handle(service_mgr__l_resp_msg_header,
1377
0
            &service_mgr__l_request_handle);
1378
0
         request_handle_bs__client_validate_response_request_handle(service_mgr__channel,
1379
0
            service_mgr__l_request_handle,
1380
0
            service_mgr__resp_typ,
1381
0
            &service_mgr__l_validated_req_handle);
1382
0
         if (service_mgr__l_validated_req_handle == true) {
1383
0
            request_handle_bs__get_req_handle_app_context(service_mgr__l_request_handle,
1384
0
               &service_mgr__l_is_applicative_response,
1385
0
               &service_mgr__l_user_app_context);
1386
0
            message_in_bs__decode_msg(service_mgr__resp_typ,
1387
0
               service_mgr__msg_buffer,
1388
0
               service_mgr__valid_resp,
1389
0
               &service_mgr__l_resp_msg);
1390
0
            if (service_mgr__l_is_applicative_response == true) {
1391
0
               if (*service_mgr__valid_resp == true) {
1392
0
                  message_in_bs__copy_msg_resp_header_into_msg(service_mgr__l_resp_msg_header,
1393
0
                     service_mgr__l_resp_msg);
1394
0
                  service_response_cb_bs__cli_service_response(constants__c_session_indet,
1395
0
                     service_mgr__l_resp_msg,
1396
0
                     service_mgr__l_user_app_context);
1397
0
                  message_in_bs__forget_msg_in(service_mgr__l_resp_msg);
1398
0
               }
1399
0
               else {
1400
0
                  request_handle_bs__get_req_handle_req_typ(service_mgr__l_request_handle,
1401
0
                     &service_mgr__l_req_typ);
1402
0
                  service_response_cb_bs__cli_snd_failure(service_mgr__l_req_typ,
1403
0
                     service_mgr__l_user_app_context,
1404
0
                     constants_statuscodes_bs__e_sc_bad_decoding_error);
1405
0
               }
1406
0
            }
1407
0
            request_handle_bs__client_remove_req_handle(service_mgr__l_request_handle);
1408
0
         }
1409
0
         message_in_bs__dealloc_msg_in_header(service_mgr__l_resp_msg_header);
1410
0
      }
1411
0
   }
1412
0
}
1413
1414
void service_mgr__server_receive_local_service_req(
1415
   const constants__t_endpoint_config_idx_i service_mgr__endpoint_config_idx,
1416
   const constants__t_msg_service_class_i service_mgr__req_class,
1417
   const constants__t_msg_type_i service_mgr__req_typ,
1418
   const constants__t_msg_i service_mgr__req_msg,
1419
   const constants__t_application_context_i service_mgr__app_context,
1420
0
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__ret) {
1421
0
   {
1422
0
      t_bool service_mgr__l_prev_local_treatment;
1423
0
      constants__t_msg_type_i service_mgr__l_resp_msg_typ;
1424
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1425
0
      constants__t_msg_i service_mgr__l_resp_msg;
1426
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1427
      
1428
0
      address_space_itf__is_local_service_treatment(&service_mgr__l_prev_local_treatment);
1429
0
      address_space_itf__set_local_service_treatment(true);
1430
0
      switch (service_mgr__req_class) {
1431
0
      case constants__e_msg_session_service_class:
1432
0
      case constants__e_msg_discovery_service_class:
1433
0
         service_mgr__get_response_type(service_mgr__req_typ,
1434
0
            &service_mgr__l_resp_msg_typ);
1435
0
         message_out_bs__alloc_resp_msg(service_mgr__l_resp_msg_typ,
1436
0
            &service_mgr__l_resp_msg_header,
1437
0
            &service_mgr__l_resp_msg);
1438
0
         break;
1439
0
      default:
1440
0
         message_out_bs__alloc_resp_msg(constants__e_msg_service_fault_resp,
1441
0
            &service_mgr__l_resp_msg_header,
1442
0
            &service_mgr__l_resp_msg);
1443
0
         break;
1444
0
      }
1445
0
      if (service_mgr__l_resp_msg != constants__c_msg_indet) {
1446
0
         *service_mgr__ret = constants_statuscodes_bs__e_sc_ok;
1447
0
         switch (service_mgr__req_class) {
1448
0
         case constants__e_msg_session_service_class:
1449
0
            service_mgr__treat_session_local_service_req(service_mgr__endpoint_config_idx,
1450
0
               service_mgr__req_typ,
1451
0
               service_mgr__req_msg,
1452
0
               service_mgr__l_resp_msg,
1453
0
               &service_mgr__l_ret);
1454
0
            break;
1455
0
         case constants__e_msg_discovery_service_class:
1456
0
            service_mgr__treat_discovery_service_req(service_mgr__endpoint_config_idx,
1457
0
               service_mgr__req_typ,
1458
0
               service_mgr__req_msg,
1459
0
               service_mgr__l_resp_msg,
1460
0
               &service_mgr__l_ret);
1461
0
            break;
1462
0
         default:
1463
0
            service_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_service_unsupported;
1464
0
            break;
1465
0
         }
1466
0
         message_out_bs__write_msg_resp_header_service_status(service_mgr__l_resp_msg_header,
1467
0
            service_mgr__l_ret);
1468
0
         message_out_bs__copy_msg_resp_header_into_msg_out(service_mgr__l_resp_msg_header,
1469
0
            service_mgr__l_resp_msg);
1470
0
         message_out_bs__dealloc_msg_header_out(service_mgr__l_resp_msg_header);
1471
0
         service_response_cb_bs__srv_service_response(service_mgr__endpoint_config_idx,
1472
0
            service_mgr__l_resp_msg,
1473
0
            service_mgr__app_context);
1474
0
         message_out_bs__forget_msg_out(service_mgr__l_resp_msg);
1475
0
      }
1476
0
      else {
1477
0
         *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1478
0
      }
1479
0
      address_space_itf__set_local_service_treatment(service_mgr__l_prev_local_treatment);
1480
0
   }
1481
0
}
1482
1483
void service_mgr__client_service_create_session(
1484
   const constants__t_session_i service_mgr__session,
1485
   const constants__t_channel_i service_mgr__channel,
1486
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1487
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
1488
0
   {
1489
0
      constants__t_msg_header_i service_mgr__l_msg_header;
1490
0
      constants__t_msg_i service_mgr__l_req_msg;
1491
0
      constants__t_client_request_handle_i service_mgr__l_req_handle;
1492
0
      t_bool service_mgr__l_valid_req_handle;
1493
0
      constants__t_byte_buffer_i service_mgr__l_buffer;
1494
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_sc;
1495
0
      t_bool service_mgr__l_bret;
1496
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
1497
      
1498
0
      service_mgr__l_buffer = constants__c_byte_buffer_indet;
1499
0
      service_mgr__l_req_handle = constants__c_client_request_handle_indet;
1500
0
      message_out_bs__alloc_req_msg(constants__e_msg_session_create_req,
1501
0
         &service_mgr__l_msg_header,
1502
0
         &service_mgr__l_req_msg);
1503
0
      if (service_mgr__l_req_msg != constants__c_msg_indet) {
1504
0
         request_handle_bs__client_fresh_req_handle(constants__e_msg_session_create_req,
1505
0
            constants__e_msg_session_create_resp,
1506
0
            false,
1507
0
            constants__c_no_application_context,
1508
0
            &service_mgr__l_req_handle);
1509
0
         request_handle_bs__is_valid_req_handle(service_mgr__l_req_handle,
1510
0
            &service_mgr__l_valid_req_handle);
1511
0
         if (service_mgr__l_valid_req_handle == true) {
1512
0
            request_handle_bs__set_req_handle_channel(service_mgr__l_req_handle,
1513
0
               service_mgr__channel);
1514
0
            session_mgr__client_create_session_req(service_mgr__session,
1515
0
               service_mgr__channel,
1516
0
               service_mgr__l_req_handle,
1517
0
               service_mgr__l_req_msg,
1518
0
               &service_mgr__l_bret);
1519
0
            if (service_mgr__l_bret == true) {
1520
0
               message_out_bs__client_write_msg_out_header_req_handle(service_mgr__l_msg_header,
1521
0
                  service_mgr__l_req_handle);
1522
0
               channel_mgr__get_channel_info(service_mgr__channel,
1523
0
                  &service_mgr__l_channel_cfg);
1524
0
               message_out_bs__encode_msg(service_mgr__l_channel_cfg,
1525
0
                  constants__e_msg_request_type,
1526
0
                  constants__e_msg_session_create_req,
1527
0
                  service_mgr__l_msg_header,
1528
0
                  service_mgr__l_req_msg,
1529
0
                  &service_mgr__l_sc,
1530
0
                  &service_mgr__l_buffer);
1531
0
               if (service_mgr__l_sc != constants_statuscodes_bs__e_sc_ok) {
1532
0
                  request_handle_bs__client_remove_req_handle(service_mgr__l_req_handle);
1533
0
                  session_mgr__client_close_session(service_mgr__session,
1534
0
                     service_mgr__l_sc);
1535
0
               }
1536
0
            }
1537
0
            else {
1538
0
               request_handle_bs__client_remove_req_handle(service_mgr__l_req_handle);
1539
0
               session_mgr__client_close_session(service_mgr__session,
1540
0
                  constants_statuscodes_bs__e_sc_bad_internal_error);
1541
0
            }
1542
0
         }
1543
0
         else {
1544
0
            session_mgr__client_close_session(service_mgr__session,
1545
0
               constants_statuscodes_bs__e_sc_bad_out_of_memory);
1546
0
         }
1547
0
         message_out_bs__dealloc_msg_header_out(service_mgr__l_msg_header);
1548
0
         message_out_bs__dealloc_msg_out(service_mgr__l_req_msg);
1549
0
      }
1550
0
      *service_mgr__buffer_out = service_mgr__l_buffer;
1551
0
      *service_mgr__req_handle = service_mgr__l_req_handle;
1552
0
   }
1553
0
}
1554
1555
void service_mgr__client_service_activate_orphaned_session(
1556
   const constants__t_session_i service_mgr__session,
1557
   const constants__t_channel_i service_mgr__channel,
1558
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1559
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
1560
0
   {
1561
0
      constants__t_msg_header_i service_mgr__l_msg_header;
1562
0
      constants__t_msg_i service_mgr__l_req_msg;
1563
0
      constants__t_client_request_handle_i service_mgr__l_req_handle;
1564
0
      t_bool service_mgr__l_valid_req_handle;
1565
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1566
0
      constants__t_session_token_i service_mgr__l_session_token;
1567
0
      constants__t_byte_buffer_i service_mgr__l_buffer;
1568
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_sc;
1569
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
1570
      
1571
0
      service_mgr__l_buffer = constants__c_byte_buffer_indet;
1572
0
      service_mgr__l_req_handle = constants__c_client_request_handle_indet;
1573
0
      message_out_bs__alloc_req_msg(constants__e_msg_session_activate_req,
1574
0
         &service_mgr__l_msg_header,
1575
0
         &service_mgr__l_req_msg);
1576
0
      if (service_mgr__l_req_msg != constants__c_msg_indet) {
1577
0
         request_handle_bs__client_fresh_req_handle(constants__e_msg_session_activate_req,
1578
0
            constants__e_msg_session_activate_resp,
1579
0
            false,
1580
0
            constants__c_no_application_context,
1581
0
            &service_mgr__l_req_handle);
1582
0
         request_handle_bs__is_valid_req_handle(service_mgr__l_req_handle,
1583
0
            &service_mgr__l_valid_req_handle);
1584
0
         if (service_mgr__l_valid_req_handle == true) {
1585
0
            request_handle_bs__set_req_handle_channel(service_mgr__l_req_handle,
1586
0
               service_mgr__channel);
1587
0
            session_mgr__client_sc_activate_session_req(service_mgr__session,
1588
0
               service_mgr__l_req_handle,
1589
0
               service_mgr__channel,
1590
0
               service_mgr__l_req_msg,
1591
0
               &service_mgr__l_ret,
1592
0
               &service_mgr__l_session_token);
1593
0
            if (service_mgr__l_ret == constants_statuscodes_bs__e_sc_ok) {
1594
0
               message_out_bs__client_write_msg_out_header_req_handle(service_mgr__l_msg_header,
1595
0
                  service_mgr__l_req_handle);
1596
0
               message_out_bs__write_msg_out_header_session_token(service_mgr__l_msg_header,
1597
0
                  service_mgr__l_session_token);
1598
0
               channel_mgr__get_channel_info(service_mgr__channel,
1599
0
                  &service_mgr__l_channel_cfg);
1600
0
               message_out_bs__encode_msg(service_mgr__l_channel_cfg,
1601
0
                  constants__e_msg_request_type,
1602
0
                  constants__e_msg_session_activate_req,
1603
0
                  service_mgr__l_msg_header,
1604
0
                  service_mgr__l_req_msg,
1605
0
                  &service_mgr__l_sc,
1606
0
                  &service_mgr__l_buffer);
1607
0
               if (service_mgr__l_sc != constants_statuscodes_bs__e_sc_ok) {
1608
0
                  request_handle_bs__client_remove_req_handle(service_mgr__l_req_handle);
1609
0
                  session_mgr__client_close_session(service_mgr__session,
1610
0
                     service_mgr__l_sc);
1611
0
               }
1612
0
            }
1613
0
         }
1614
0
         message_out_bs__dealloc_msg_header_out(service_mgr__l_msg_header);
1615
0
         message_out_bs__dealloc_msg_out(service_mgr__l_req_msg);
1616
0
      }
1617
0
      else {
1618
0
         session_mgr__client_close_session(service_mgr__session,
1619
0
            constants_statuscodes_bs__e_sc_bad_out_of_memory);
1620
0
      }
1621
0
      *service_mgr__buffer_out = service_mgr__l_buffer;
1622
0
      *service_mgr__req_handle = service_mgr__l_req_handle;
1623
0
   }
1624
0
}
1625
1626
void service_mgr__client_service_activate_session(
1627
   const constants__t_session_i service_mgr__session,
1628
   const constants__t_user_token_i service_mgr__p_user_token,
1629
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__ret,
1630
   constants__t_channel_i * const service_mgr__channel,
1631
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1632
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
1633
0
   {
1634
0
      constants__t_msg_header_i service_mgr__l_msg_header;
1635
0
      constants__t_msg_i service_mgr__l_req_msg;
1636
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1637
0
      constants__t_channel_i service_mgr__l_channel;
1638
0
      constants__t_client_request_handle_i service_mgr__l_req_handle;
1639
0
      t_bool service_mgr__l_valid_req_handle;
1640
0
      constants__t_session_token_i service_mgr__l_session_token;
1641
0
      constants__t_byte_buffer_i service_mgr__l_buffer;
1642
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
1643
      
1644
0
      service_mgr__l_channel = constants__c_channel_indet;
1645
0
      service_mgr__l_buffer = constants__c_byte_buffer_indet;
1646
0
      service_mgr__l_req_handle = constants__c_client_request_handle_indet;
1647
0
      message_out_bs__alloc_req_msg(constants__e_msg_session_activate_req,
1648
0
         &service_mgr__l_msg_header,
1649
0
         &service_mgr__l_req_msg);
1650
0
      if (service_mgr__l_req_msg != constants__c_msg_indet) {
1651
0
         request_handle_bs__client_fresh_req_handle(constants__e_msg_session_activate_req,
1652
0
            constants__e_msg_session_activate_resp,
1653
0
            false,
1654
0
            constants__c_no_application_context,
1655
0
            &service_mgr__l_req_handle);
1656
0
         request_handle_bs__is_valid_req_handle(service_mgr__l_req_handle,
1657
0
            &service_mgr__l_valid_req_handle);
1658
0
         if (service_mgr__l_valid_req_handle == true) {
1659
0
            session_mgr__client_user_activate_session_req(service_mgr__session,
1660
0
               service_mgr__l_req_handle,
1661
0
               service_mgr__p_user_token,
1662
0
               service_mgr__l_req_msg,
1663
0
               &service_mgr__l_ret,
1664
0
               &service_mgr__l_channel,
1665
0
               &service_mgr__l_session_token);
1666
0
            if (service_mgr__l_ret == constants_statuscodes_bs__e_sc_ok) {
1667
0
               request_handle_bs__set_req_handle_channel(service_mgr__l_req_handle,
1668
0
                  service_mgr__l_channel);
1669
0
               message_out_bs__client_write_msg_out_header_req_handle(service_mgr__l_msg_header,
1670
0
                  service_mgr__l_req_handle);
1671
0
               message_out_bs__write_msg_out_header_session_token(service_mgr__l_msg_header,
1672
0
                  service_mgr__l_session_token);
1673
0
               channel_mgr__get_channel_info(service_mgr__l_channel,
1674
0
                  &service_mgr__l_channel_cfg);
1675
0
               message_out_bs__encode_msg(service_mgr__l_channel_cfg,
1676
0
                  constants__e_msg_request_type,
1677
0
                  constants__e_msg_session_activate_req,
1678
0
                  service_mgr__l_msg_header,
1679
0
                  service_mgr__l_req_msg,
1680
0
                  &service_mgr__l_ret,
1681
0
                  &service_mgr__l_buffer);
1682
0
               if (service_mgr__l_ret != constants_statuscodes_bs__e_sc_ok) {
1683
0
                  request_handle_bs__client_remove_req_handle(service_mgr__l_req_handle);
1684
0
                  service_mgr__l_channel = constants__c_channel_indet;
1685
0
                  session_mgr__client_close_session(service_mgr__session,
1686
0
                     service_mgr__l_ret);
1687
0
               }
1688
0
            }
1689
0
            else {
1690
0
               session_mgr__client_close_session(service_mgr__session,
1691
0
                  service_mgr__l_ret);
1692
0
            }
1693
0
         }
1694
0
         else {
1695
0
            session_mgr__client_close_session(service_mgr__session,
1696
0
               constants_statuscodes_bs__e_sc_bad_out_of_memory);
1697
0
            service_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1698
0
         }
1699
0
         message_out_bs__dealloc_msg_header_out(service_mgr__l_msg_header);
1700
0
         message_out_bs__dealloc_msg_out(service_mgr__l_req_msg);
1701
0
      }
1702
0
      else {
1703
0
         session_mgr__client_close_session(service_mgr__session,
1704
0
            constants_statuscodes_bs__e_sc_bad_out_of_memory);
1705
0
         service_mgr__l_ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1706
0
      }
1707
0
      *service_mgr__ret = service_mgr__l_ret;
1708
0
      *service_mgr__channel = service_mgr__l_channel;
1709
0
      *service_mgr__req_handle = service_mgr__l_req_handle;
1710
0
      *service_mgr__buffer_out = service_mgr__l_buffer;
1711
0
   }
1712
0
}
1713
1714
void service_mgr__client_service_close_session(
1715
   const constants__t_session_i service_mgr__session,
1716
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__ret,
1717
   constants__t_channel_i * const service_mgr__channel,
1718
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1719
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
1720
0
   {
1721
0
      constants__t_msg_header_i service_mgr__l_msg_header;
1722
0
      constants__t_msg_i service_mgr__l_req_msg;
1723
0
      constants__t_channel_i service_mgr__l_channel;
1724
0
      constants__t_client_request_handle_i service_mgr__l_req_handle;
1725
0
      t_bool service_mgr__l_valid_req_handle;
1726
0
      constants__t_session_token_i service_mgr__l_session_token;
1727
0
      constants__t_byte_buffer_i service_mgr__l_buffer;
1728
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
1729
      
1730
0
      service_mgr__l_channel = constants__c_channel_indet;
1731
0
      service_mgr__l_buffer = constants__c_byte_buffer_indet;
1732
0
      service_mgr__l_req_handle = constants__c_client_request_handle_indet;
1733
0
      message_out_bs__alloc_req_msg(constants__e_msg_session_close_req,
1734
0
         &service_mgr__l_msg_header,
1735
0
         &service_mgr__l_req_msg);
1736
0
      if (service_mgr__l_req_msg != constants__c_msg_indet) {
1737
0
         request_handle_bs__client_fresh_req_handle(constants__e_msg_session_close_req,
1738
0
            constants__e_msg_session_close_resp,
1739
0
            false,
1740
0
            constants__c_no_application_context,
1741
0
            &service_mgr__l_req_handle);
1742
0
         request_handle_bs__is_valid_req_handle(service_mgr__l_req_handle,
1743
0
            &service_mgr__l_valid_req_handle);
1744
0
         if (service_mgr__l_valid_req_handle == true) {
1745
0
            session_mgr__client_close_session_req(service_mgr__session,
1746
0
               service_mgr__l_req_handle,
1747
0
               service_mgr__l_req_msg,
1748
0
               service_mgr__ret,
1749
0
               &service_mgr__l_channel,
1750
0
               &service_mgr__l_session_token);
1751
0
            if (*service_mgr__ret == constants_statuscodes_bs__e_sc_ok) {
1752
0
               request_handle_bs__set_req_handle_channel(service_mgr__l_req_handle,
1753
0
                  service_mgr__l_channel);
1754
0
               message_out_bs__client_write_msg_out_header_req_handle(service_mgr__l_msg_header,
1755
0
                  service_mgr__l_req_handle);
1756
0
               message_out_bs__write_msg_out_header_session_token(service_mgr__l_msg_header,
1757
0
                  service_mgr__l_session_token);
1758
0
               channel_mgr__get_channel_info(service_mgr__l_channel,
1759
0
                  &service_mgr__l_channel_cfg);
1760
0
               message_out_bs__encode_msg(service_mgr__l_channel_cfg,
1761
0
                  constants__e_msg_request_type,
1762
0
                  constants__e_msg_session_close_req,
1763
0
                  service_mgr__l_msg_header,
1764
0
                  service_mgr__l_req_msg,
1765
0
                  service_mgr__ret,
1766
0
                  &service_mgr__l_buffer);
1767
0
               if (*service_mgr__ret != constants_statuscodes_bs__e_sc_ok) {
1768
0
                  service_mgr__l_channel = constants__c_channel_indet;
1769
0
                  request_handle_bs__client_remove_req_handle(service_mgr__l_req_handle);
1770
0
               }
1771
0
            }
1772
0
         }
1773
0
         else {
1774
0
            *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1775
0
         }
1776
0
         message_out_bs__dealloc_msg_header_out(service_mgr__l_msg_header);
1777
0
         message_out_bs__dealloc_msg_out(service_mgr__l_req_msg);
1778
0
      }
1779
0
      else {
1780
0
         *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1781
0
      }
1782
0
      if (*service_mgr__ret != constants_statuscodes_bs__e_sc_ok) {
1783
0
         session_mgr__client_close_session(service_mgr__session,
1784
0
            *service_mgr__ret);
1785
0
      }
1786
0
      *service_mgr__channel = service_mgr__l_channel;
1787
0
      *service_mgr__buffer_out = service_mgr__l_buffer;
1788
0
      *service_mgr__req_handle = service_mgr__l_req_handle;
1789
0
   }
1790
0
}
1791
1792
void service_mgr__client_service_request(
1793
   const constants__t_session_i service_mgr__session,
1794
   const constants__t_msg_type_i service_mgr__req_typ,
1795
   const constants__t_msg_i service_mgr__req_msg,
1796
   const constants__t_application_context_i service_mgr__app_context,
1797
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__ret,
1798
   constants__t_channel_i * const service_mgr__channel,
1799
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1800
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
1801
0
   {
1802
0
      constants__t_msg_header_i service_mgr__l_msg_header;
1803
0
      constants__t_msg_type_i service_mgr__l_resp_typ;
1804
0
      constants__t_channel_i service_mgr__l_channel;
1805
0
      constants__t_client_request_handle_i service_mgr__l_req_handle;
1806
0
      t_bool service_mgr__l_valid_req_handle;
1807
0
      constants__t_session_token_i service_mgr__l_session_token;
1808
0
      constants__t_byte_buffer_i service_mgr__l_buffer;
1809
0
      t_bool service_mgr__l_valid_channel;
1810
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
1811
      
1812
0
      service_mgr__l_channel = constants__c_channel_indet;
1813
0
      service_mgr__l_buffer = constants__c_byte_buffer_indet;
1814
0
      service_mgr__l_req_handle = constants__c_client_request_handle_indet;
1815
0
      switch (service_mgr__req_typ) {
1816
0
      case constants__e_msg_node_add_nodes_req:
1817
0
      case constants__e_msg_node_add_references_req:
1818
0
      case constants__e_msg_node_delete_nodes_req:
1819
0
      case constants__e_msg_node_delete_references_req:
1820
0
      case constants__e_msg_view_browse_req:
1821
0
      case constants__e_msg_view_browse_next_req:
1822
0
      case constants__e_msg_view_translate_browse_paths_to_node_ids_req:
1823
0
      case constants__e_msg_view_register_nodes_req:
1824
0
      case constants__e_msg_view_unregister_nodes_req:
1825
0
      case constants__e_msg_query_first_req:
1826
0
      case constants__e_msg_query_next_req:
1827
0
      case constants__e_msg_attribute_read_req:
1828
0
      case constants__e_msg_attribute_history_read_req:
1829
0
      case constants__e_msg_attribute_write_req:
1830
0
      case constants__e_msg_attribute_history_update_req:
1831
0
      case constants__e_msg_method_call_req:
1832
0
      case constants__e_msg_monitored_items_create_req:
1833
0
      case constants__e_msg_monitored_items_modify_req:
1834
0
      case constants__e_msg_monitored_items_set_monitoring_mode_req:
1835
0
      case constants__e_msg_monitored_items_set_monitoring_mode_resp:
1836
0
      case constants__e_msg_monitored_items_set_triggering_req:
1837
0
      case constants__e_msg_monitored_items_delete_req:
1838
0
      case constants__e_msg_subscription_create_req:
1839
0
      case constants__e_msg_subscription_modify_req:
1840
0
      case constants__e_msg_subscription_set_publishing_mode_req:
1841
0
      case constants__e_msg_subscription_publish_req:
1842
0
      case constants__e_msg_subscription_republish_req:
1843
0
      case constants__e_msg_subscription_transfer_subscriptions_req:
1844
0
      case constants__e_msg_subscription_delete_subscriptions_req:
1845
0
         service_mgr__get_response_type(service_mgr__req_typ,
1846
0
            &service_mgr__l_resp_typ);
1847
0
         message_out_bs__alloc_msg_header(true,
1848
0
            &service_mgr__l_msg_header);
1849
0
         request_handle_bs__client_fresh_req_handle(service_mgr__req_typ,
1850
0
            service_mgr__l_resp_typ,
1851
0
            true,
1852
0
            service_mgr__app_context,
1853
0
            &service_mgr__l_req_handle);
1854
0
         request_handle_bs__is_valid_req_handle(service_mgr__l_req_handle,
1855
0
            &service_mgr__l_valid_req_handle);
1856
0
         if ((service_mgr__l_valid_req_handle == true) &&
1857
0
            (service_mgr__l_msg_header != constants__c_msg_header_indet)) {
1858
0
            session_mgr__client_validate_session_service_req(service_mgr__session,
1859
0
               service_mgr__l_req_handle,
1860
0
               service_mgr__ret,
1861
0
               &service_mgr__l_channel,
1862
0
               &service_mgr__l_session_token);
1863
0
            if (*service_mgr__ret == constants_statuscodes_bs__e_sc_ok) {
1864
0
               request_handle_bs__set_req_handle_channel(service_mgr__l_req_handle,
1865
0
                  service_mgr__l_channel);
1866
0
               message_out_bs__client_write_msg_out_header_req_handle(service_mgr__l_msg_header,
1867
0
                  service_mgr__l_req_handle);
1868
0
               message_out_bs__write_msg_out_header_session_token(service_mgr__l_msg_header,
1869
0
                  service_mgr__l_session_token);
1870
0
               channel_mgr__get_channel_info(service_mgr__l_channel,
1871
0
                  &service_mgr__l_channel_cfg);
1872
0
               message_out_bs__encode_msg(service_mgr__l_channel_cfg,
1873
0
                  constants__e_msg_request_type,
1874
0
                  constants__e_msg_session_close_req,
1875
0
                  service_mgr__l_msg_header,
1876
0
                  service_mgr__req_msg,
1877
0
                  service_mgr__ret,
1878
0
                  &service_mgr__l_buffer);
1879
0
               if (*service_mgr__ret != constants_statuscodes_bs__e_sc_ok) {
1880
0
                  service_mgr__l_channel = constants__c_channel_indet;
1881
0
               }
1882
0
            }
1883
0
         }
1884
0
         else {
1885
0
            *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_out_of_memory;
1886
0
         }
1887
0
         if (service_mgr__l_msg_header != constants__c_msg_header_indet) {
1888
0
            message_out_bs__dealloc_msg_header_out(service_mgr__l_msg_header);
1889
0
         }
1890
0
         break;
1891
0
      case constants__e_msg_discovery_find_servers_req:
1892
0
      case constants__e_msg_discovery_find_servers_on_network_req:
1893
0
      case constants__e_msg_discovery_get_endpoints_req:
1894
0
      case constants__e_msg_discovery_register_server_req:
1895
0
      case constants__e_msg_discovery_register_server2_req:
1896
0
         session_mgr__getall_valid_session_channel(service_mgr__session,
1897
0
            &service_mgr__l_valid_channel,
1898
0
            &service_mgr__l_channel);
1899
0
         if (service_mgr__l_valid_channel == true) {
1900
0
            service_mgr__local_client_discovery_service_request(service_mgr__l_channel,
1901
0
               service_mgr__req_typ,
1902
0
               service_mgr__req_msg,
1903
0
               service_mgr__app_context,
1904
0
               service_mgr__ret,
1905
0
               &service_mgr__l_buffer,
1906
0
               &service_mgr__l_req_handle);
1907
0
            if (*service_mgr__ret != constants_statuscodes_bs__e_sc_ok) {
1908
0
               service_mgr__l_channel = constants__c_channel_indet;
1909
0
            }
1910
0
         }
1911
0
         else {
1912
0
            *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
1913
0
         }
1914
0
         break;
1915
0
      default:
1916
0
         *service_mgr__ret = constants_statuscodes_bs__e_sc_bad_invalid_argument;
1917
0
         break;
1918
0
      }
1919
0
      *service_mgr__channel = service_mgr__l_channel;
1920
0
      *service_mgr__req_handle = service_mgr__l_req_handle;
1921
0
      *service_mgr__buffer_out = service_mgr__l_buffer;
1922
0
   }
1923
0
}
1924
1925
void service_mgr__client_discovery_service_request(
1926
   const constants__t_channel_i service_mgr__channel,
1927
   const constants__t_msg_type_i service_mgr__req_typ,
1928
   const constants__t_msg_i service_mgr__req_msg,
1929
   const constants__t_application_context_i service_mgr__app_context,
1930
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__ret,
1931
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1932
0
   constants__t_client_request_handle_i * const service_mgr__req_handle) {
1933
0
   service_mgr__local_client_discovery_service_request(service_mgr__channel,
1934
0
      service_mgr__req_typ,
1935
0
      service_mgr__req_msg,
1936
0
      service_mgr__app_context,
1937
0
      service_mgr__ret,
1938
0
      service_mgr__buffer_out,
1939
0
      service_mgr__req_handle);
1940
0
}
1941
1942
void service_mgr__client_snd_msg_failure(
1943
   const constants__t_channel_i service_mgr__channel,
1944
   const constants__t_client_request_handle_i service_mgr__request_handle,
1945
0
   const constants_statuscodes_bs__t_StatusCode_i service_mgr__error_status) {
1946
0
   service_mgr__l_client_snd_msg_failure(service_mgr__channel,
1947
0
      service_mgr__request_handle,
1948
0
      service_mgr__error_status);
1949
0
}
1950
1951
void service_mgr__client_snd_all_msg_failure(
1952
   const constants__t_channel_i service_mgr__channel,
1953
0
   const constants_statuscodes_bs__t_StatusCode_i service_mgr__error_status) {
1954
0
   {
1955
0
      t_bool service_mgr__l_continue;
1956
0
      constants__t_client_request_handle_i service_mgr__l_request_handle;
1957
      
1958
0
      request_handle_bs__init_channel_req_handle_it(service_mgr__channel,
1959
0
         &service_mgr__l_continue);
1960
0
      if (service_mgr__l_continue == true) {
1961
0
         while (service_mgr__l_continue == true) {
1962
0
            request_handle_bs__continue_channel_req_handle_it(&service_mgr__l_continue,
1963
0
               &service_mgr__l_request_handle);
1964
0
            service_mgr__l_client_snd_msg_failure(service_mgr__channel,
1965
0
               service_mgr__l_request_handle,
1966
0
               service_mgr__error_status);
1967
0
         }
1968
0
      }
1969
0
   }
1970
0
}
1971
1972
void service_mgr__server_send_publish_response(
1973
   const constants__t_session_i service_mgr__session,
1974
   const constants__t_server_request_handle_i service_mgr__req_handle,
1975
   const constants_statuscodes_bs__t_StatusCode_i service_mgr__statusCode,
1976
   const constants__t_msg_type_i service_mgr__resp_typ,
1977
   const constants__t_msg_i service_mgr__publish_resp_msg,
1978
   t_bool * const service_mgr__bres,
1979
   constants_statuscodes_bs__t_StatusCode_i * const service_mgr__sc,
1980
   constants__t_byte_buffer_i * const service_mgr__buffer_out,
1981
0
   constants__t_channel_i * const service_mgr__channel) {
1982
0
   {
1983
0
      t_bool service_mgr__l_is_valid_resp;
1984
0
      constants_statuscodes_bs__t_StatusCode_i service_mgr__l_ret;
1985
0
      constants__t_msg_header_i service_mgr__l_resp_msg_header;
1986
0
      constants__t_byte_buffer_i service_mgr__l_buffer_out;
1987
0
      constants__t_channel_config_idx_i service_mgr__l_channel_cfg;
1988
      
1989
0
      *service_mgr__sc = constants_statuscodes_bs__e_sc_bad_session_id_invalid;
1990
0
      *service_mgr__bres = false;
1991
0
      *service_mgr__buffer_out = constants__c_byte_buffer_indet;
1992
0
      *service_mgr__channel = constants__c_channel_indet;
1993
0
      session_mgr__server_validate_async_session_service_resp(service_mgr__session,
1994
0
         &service_mgr__l_is_valid_resp,
1995
0
         &service_mgr__l_ret,
1996
0
         service_mgr__channel);
1997
0
      if (service_mgr__l_is_valid_resp == true) {
1998
0
         message_out_bs__alloc_msg_header(false,
1999
0
            &service_mgr__l_resp_msg_header);
2000
0
         if (service_mgr__l_resp_msg_header != constants__c_msg_header_indet) {
2001
0
            message_out_bs__server_write_msg_out_header_req_handle(service_mgr__l_resp_msg_header,
2002
0
               service_mgr__req_handle);
2003
0
            message_out_bs__write_msg_resp_header_service_status(service_mgr__l_resp_msg_header,
2004
0
               service_mgr__statusCode);
2005
0
            channel_mgr__get_channel_info(*service_mgr__channel,
2006
0
               &service_mgr__l_channel_cfg);
2007
0
            message_out_bs__encode_msg(service_mgr__l_channel_cfg,
2008
0
               constants__e_msg_response_type,
2009
0
               service_mgr__resp_typ,
2010
0
               service_mgr__l_resp_msg_header,
2011
0
               service_mgr__publish_resp_msg,
2012
0
               service_mgr__sc,
2013
0
               &service_mgr__l_buffer_out);
2014
0
            message_out_bs__dealloc_msg_header_out(service_mgr__l_resp_msg_header);
2015
0
            if (*service_mgr__sc == constants_statuscodes_bs__e_sc_ok) {
2016
0
               *service_mgr__buffer_out = service_mgr__l_buffer_out;
2017
0
               *service_mgr__bres = true;
2018
0
            }
2019
0
         }
2020
0
         else {
2021
0
            *service_mgr__sc = constants_statuscodes_bs__e_sc_bad_out_of_memory;
2022
0
         }
2023
0
      }
2024
0
   }
2025
0
}
2026
2027
void service_mgr__internal_server_inactive_session_prio_event(
2028
   const constants__t_session_i service_mgr__p_session,
2029
   const constants__t_sessionState_i service_mgr__p_newSessionState,
2030
0
   t_bool * const service_mgr__bres) {
2031
0
   if (service_mgr__p_session != constants__c_session_indet) {
2032
0
      *service_mgr__bres = true;
2033
0
      subscription_mgr__server_subscription_session_inactive(service_mgr__p_session,
2034
0
         service_mgr__p_newSessionState);
2035
0
      if (service_mgr__p_newSessionState == constants__e_session_closed) {
2036
0
         service_set_view__service_set_view_set_session_closed(service_mgr__p_session);
2037
0
      }
2038
0
   }
2039
0
   else {
2040
0
      *service_mgr__bres = false;
2041
0
   }
2042
0
}
2043
2044
0
void service_mgr__service_mgr_UNINITIALISATION(void) {
2045
0
   subscription_mgr__subscription_mgr_UNINITIALISATION();
2046
0
   session_mgr__session_mgr_UNINITIALISATION();
2047
0
   service_set_view__service_set_view_UNINITIALISATION();
2048
0
   service_set_discovery_server__service_set_discovery_server_UNINITIALISATION();
2049
0
   service_mgr_bs__service_mgr_bs_UNINITIALISATION();
2050
0
   address_space_itf__address_space_UNINITIALISATION();
2051
0
}
2052