Changes to Subscription Handler
[ric-app/hw.git] / src / xapp-formats / e2sm / e2sm.cc
1 /*
2   ==================================================================================
3
4   Copyright (c) 2018-2019 AT&T Intellectual Property.
5   
6   Licensed under the Apache License, Version 2.0 (the "License");
7   you may not use this file except in compliance with the License.
8   You may obtain 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, softwares
13   distributed under the License is distributed on an "AS IS" BASIS,
14   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   See the License for the specific language governing permissions and
16   limitations under the License.
17   ==================================================================================
18 */
19
20 /* Classes to handle E2 service model based on e2sm-gNB-X2-release-1-v040.asn */
21
22 #include "e2sm.hpp"
23
24
25
26   //initialize
27   e2sm_event_trigger::e2sm_event_trigger(void){
28
29     memset(&gNodeB_ID, 0, sizeof(E2N_GlobalGNB_ID_t));
30
31     event_trigger = 0;
32     event_trigger = ( E2N_E2SM_gNB_X2_eventTriggerDefinition_t *)calloc(1, sizeof( E2N_E2SM_gNB_X2_eventTriggerDefinition_t));
33     assert(event_trigger != 0);
34     
35     // allocate space for gNodeB id  (used for encoding)
36     gNodeB_ID.gNB_ID.choice.gNB_ID.buf = 0;
37     gNodeB_ID.gNB_ID.choice.gNB_ID.buf = (uint8_t *)calloc(4, sizeof(uint8_t));
38     assert(gNodeB_ID.gNB_ID.choice.gNB_ID.buf != 0);
39     
40     // allocate space for plmn identity  (used for encoding)
41     gNodeB_ID.pLMN_Identity.buf = 0;
42     gNodeB_ID.pLMN_Identity.buf = (uint8_t *) calloc(4, sizeof(uint8_t));
43     assert(gNodeB_ID.pLMN_Identity.buf != 0);
44
45     ie_list = 0;
46     ie_list = ( struct E2N_InterfaceProtocolIE_Item *) calloc(INITIAL_LIST_SIZE, sizeof( struct E2N_InterfaceProtocolIE_Item));
47     assert(ie_list != 0);
48     ie_list_size = INITIAL_LIST_SIZE;
49
50     condition_list = 0;
51     condition_list = (E2N_E2SM_gNB_X2_eventTriggerDefinition::E2N_E2SM_gNB_X2_eventTriggerDefinition__interfaceProtocolIE_List *) calloc(1, sizeof(E2N_E2SM_gNB_X2_eventTriggerDefinition::E2N_E2SM_gNB_X2_eventTriggerDefinition__interfaceProtocolIE_List ));
52     assert(condition_list != 0);
53
54  
55     
56   };
57   
58 e2sm_event_trigger::~e2sm_event_trigger(void){
59
60   mdclog_write(MDCLOG_DEBUG, "Freeing event trigger object memory");
61   for(int i = 0; i < condition_list->list.size; i++){
62     condition_list->list.array[i] = 0;
63   }
64
65   if (condition_list->list.size > 0){
66     free(condition_list->list.array);
67     condition_list->list.array = 0;
68     condition_list->list.size = 0;
69     condition_list->list.count = 0;
70   }
71
72   free(condition_list);
73   condition_list = 0;
74   
75   free(gNodeB_ID.gNB_ID.choice.gNB_ID.buf);
76   gNodeB_ID.gNB_ID.choice.gNB_ID.buf = 0;
77   
78   free(gNodeB_ID.pLMN_Identity.buf);
79   gNodeB_ID.pLMN_Identity.buf = 0;
80   
81   free(ie_list);
82   ie_list = 0;
83   
84   event_trigger->interface_ID.choice.global_gNB_ID = 0;
85   event_trigger->interfaceProtocolIE_List = 0;
86   
87   ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger);
88   mdclog_write(MDCLOG_DEBUG, "Freed event trigger object memory");
89
90  
91 };
92
93 bool e2sm_event_trigger::encode_event_trigger(unsigned char *buf, size_t *size, e2sm_event_trigger_helper &helper){
94   
95   bool res;
96   res = set_fields(event_trigger, helper);
97   if (!res){
98     return false;
99   }
100   
101   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger, errbuf, &errbuf_len);
102   if(ret_constr){
103     error_string.assign(&errbuf[0], errbuf_len);
104     return false;
105   }
106
107   //xer_fprint(stdout, &asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger);
108   
109   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger, buf, *size);
110   
111   if(retval.encoded == -1){
112     error_string.assign(strerror(errno));
113     return false;
114   }
115   else if (retval.encoded > *size){
116     std::stringstream ss;
117     ss  <<"Error encoding event trigger definition. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
118     error_string = ss.str();
119     return false;
120   }
121   else{
122     *size = retval.encoded;
123   }
124   
125   return true;
126 }
127
128
129 bool e2sm_event_trigger::set_fields(E2N_E2SM_gNB_X2_eventTriggerDefinition_t * ref_event_trigger, e2sm_event_trigger_helper & helper){
130   if(ref_event_trigger == 0){
131     error_string = "Invalid reference for Event Trigger Definition set fields";
132     return false;
133   }
134       
135   // set the message type
136   ref_event_trigger->interfaceMessageType.procedureCode = helper.procedure_code;
137   ref_event_trigger->interfaceMessageType.typeOfMessage = helper.message_type;
138   
139   ref_event_trigger->interfaceDirection = helper.interface_direction; 
140   ref_event_trigger->interface_ID.present = E2N_Interface_ID_PR_global_gNB_ID;
141   
142   ref_event_trigger->interface_ID.choice.global_gNB_ID = &gNodeB_ID;
143
144   // to do : need to put correct code here for upding plmn id and gNodeB
145   // for now just place holders :
146   //================================================================
147   memcpy(gNodeB_ID.pLMN_Identity.buf, helper.plmn_id.c_str(), 3);
148   gNodeB_ID.pLMN_Identity.size = 3;
149   
150   memcpy(gNodeB_ID.gNB_ID.choice.gNB_ID.buf, helper.egNB_id.c_str(), 3);
151   gNodeB_ID.gNB_ID.choice.gNB_ID.size = 3;
152   
153   // we only do global gNodeB id for now, not eNodeB
154   gNodeB_ID.gNB_ID.present = E2N_GNB_ID_PR_gNB_ID;
155   //================================================================
156   
157   
158   // Add in any requested IE items
159   std::vector<Item> * ref_ie_array = helper.get_list();
160
161   if (ref_ie_array->size() == 0){
162     ref_event_trigger->interfaceProtocolIE_List = 0;
163     
164   }
165   else{
166     ref_event_trigger->interfaceProtocolIE_List = condition_list;
167     
168     //resize memory ? 
169     if(ref_ie_array->size() > ie_list_size){
170       ie_list_size = 2 * ref_ie_array->size();
171       free(ie_list);
172       ie_list = (struct E2N_InterfaceProtocolIE_Item *)calloc(ie_list_size, sizeof(struct E2N_InterfaceProtocolIE_Item));
173       assert(ie_list != 0);
174     }
175     
176     // reset the count so that adds start from the beginning
177     ref_event_trigger->interfaceProtocolIE_List->list.count = 0;
178     
179     for(unsigned int i = 0; i < ref_ie_array->size(); i++){
180
181       ie_list[i].interfaceProtocolIE_ID = (*ref_ie_array)[i].interface_id;
182       ie_list[i].interfaceProtocolIE_Test = (*ref_ie_array)[i].test;
183       
184       //switch(ie_list[i].interfaceProtocolIE_Value.present){
185       switch((*ref_ie_array)[i].val_type){
186         
187       case (E2N_InterfaceProtocolIE_Value_PR_valueInt):
188         ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueInt;
189         ie_list[i].interfaceProtocolIE_Value.choice.valueInt = (*ref_ie_array)[i].value_n;
190         break;
191         
192       case (E2N_InterfaceProtocolIE_Value_PR_valueEnum):
193         ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueEnum;
194         ie_list[i].interfaceProtocolIE_Value.choice.valueEnum = (*ref_ie_array)[i].value_n;
195         break;
196         
197       case (E2N_InterfaceProtocolIE_Value_PR_valueBool):
198         ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueBool;
199         ie_list[i].interfaceProtocolIE_Value.choice.valueBool = (*ref_ie_array)[i].value_n;
200         break;
201         
202       case (E2N_InterfaceProtocolIE_Value_PR_valueBitS):
203         ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueBitS;
204         ie_list[i].interfaceProtocolIE_Value.choice.valueBitS.buf = (uint8_t *)(*ref_ie_array)[i].value_s.c_str();
205         ie_list[i].interfaceProtocolIE_Value.choice.valueBitS.size = (*ref_ie_array)[i].value_s.length();
206         break;
207
208       case (E2N_InterfaceProtocolIE_Value_PR_valueOctS):
209         ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueOctS;
210         ie_list[i].interfaceProtocolIE_Value.choice.valueOctS.buf = (uint8_t *)(*ref_ie_array)[i].value_s.c_str();
211         ie_list[i].interfaceProtocolIE_Value.choice.valueOctS.size = (*ref_ie_array)[i].value_s.length();
212         break;
213
214       default:
215         {
216           std::stringstream ss;
217           ss <<"Error ! " << __FILE__ << "," << __LINE__ << " illegal enum " << (*ref_ie_array)[i].val_type << " for interface Protocol IE value" << std::endl;
218           std::string error_string = ss.str();
219           return false;
220         }
221       }
222       
223       ASN_SEQUENCE_ADD(ref_event_trigger->interfaceProtocolIE_List, &ie_list[i]);
224     }
225   }
226
227   return true;
228 };
229   
230
231 bool e2sm_event_trigger::get_fields(E2N_E2SM_gNB_X2_eventTriggerDefinition_t * ref_event_trigger, e2sm_event_trigger_helper & helper){
232
233   if (ref_event_trigger == 0){
234     error_string = "Invalid reference for Event Trigger definition get fields";
235     return false;
236   }
237   
238   helper.procedure_code = ref_event_trigger->interfaceMessageType.procedureCode;
239   helper.message_type   = ref_event_trigger->interfaceMessageType.typeOfMessage;
240   helper.interface_direction = ref_event_trigger->interfaceDirection;
241   
242   helper.plmn_id.assign((const char *)ref_event_trigger->interface_ID.choice.global_gNB_ID->pLMN_Identity.buf, ref_event_trigger->interface_ID.choice.global_gNB_ID->pLMN_Identity.size);
243   helper.egNB_id.assign((const char *)ref_event_trigger->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.buf, ref_event_trigger->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.size);
244   for(int i = 0; i < ref_event_trigger->interfaceProtocolIE_List->list.count; i++){
245     struct E2N_InterfaceProtocolIE_Item * ie_item = ref_event_trigger->interfaceProtocolIE_List->list.array[i];
246     switch(ie_item->interfaceProtocolIE_Value.present){
247     case (E2N_InterfaceProtocolIE_Value_PR_valueInt):
248       helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, ie_item->interfaceProtocolIE_Value.choice.valueInt);
249       break;
250     case (E2N_InterfaceProtocolIE_Value_PR_valueEnum):
251       helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, ie_item->interfaceProtocolIE_Value.choice.valueEnum);
252       break;
253     case (E2N_InterfaceProtocolIE_Value_PR_valueBool):
254       helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, ie_item->interfaceProtocolIE_Value.choice.valueBool);     
255       break;
256     case (E2N_InterfaceProtocolIE_Value_PR_valueBitS):
257       helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, std::string((const char *)ie_item->interfaceProtocolIE_Value.choice.valueBitS.buf,ie_item->interfaceProtocolIE_Value.choice.valueBitS.size) );
258       break;
259     case (E2N_InterfaceProtocolIE_Value_PR_valueOctS):
260       helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, std::string((const char *)ie_item->interfaceProtocolIE_Value.choice.valueOctS.buf,ie_item->interfaceProtocolIE_Value.choice.valueOctS.size) );
261       break;
262     default:
263       mdclog_write(MDCLOG_ERR, "Error : %s, %d: Unkown interface protocol IE type %d in event trigger definition\n", __FILE__, __LINE__, ie_item->interfaceProtocolIE_Value.present);
264       return false;
265     }
266   }
267   
268   return true;
269 };
270     
271
272   
273    
274 // initialize
275 e2sm_indication::e2sm_indication(void) {
276   
277   memset(&gNodeB_ID, 0, sizeof(E2N_GlobalGNB_ID_t));
278     
279   // allocate space for gNodeB id  (used for encoding)
280   gNodeB_ID.gNB_ID.choice.gNB_ID.buf = (uint8_t *)calloc(4, sizeof(uint8_t));
281   assert(gNodeB_ID.gNB_ID.choice.gNB_ID.buf != 0);
282     
283   // allocate space for plmn identity  (used for encoding)
284   gNodeB_ID.pLMN_Identity.buf = (uint8_t *) calloc(4, sizeof(uint8_t));
285   assert(gNodeB_ID.pLMN_Identity.buf != 0);
286
287   header = 0;
288   header = (E2N_E2SM_gNB_X2_indicationHeader_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_indicationHeader_t));
289   assert(header != 0);
290
291   message = 0;
292   message = (E2N_E2SM_gNB_X2_indicationMessage_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_indicationMessage_t));
293   assert(message != 0);
294 }
295   
296 e2sm_indication::~e2sm_indication(void){
297   mdclog_write(MDCLOG_DEBUG, "Freeing E2N_E2SM Indication  object memory");
298
299   free(gNodeB_ID.gNB_ID.choice.gNB_ID.buf);
300   free(gNodeB_ID.pLMN_Identity.buf);
301   
302   header->interface_ID.choice.global_gNB_ID = 0;
303
304   ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header);
305
306   message->interfaceMessage.buf = 0;
307   message->interfaceMessage.size = 0;
308
309   ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message);
310   mdclog_write(MDCLOG_DEBUG, "Freed E2SM Indication  object memory");
311     
312 }
313   
314   
315
316 bool e2sm_indication::encode_indication_header(unsigned char *buf, size_t *size, e2sm_header_helper &helper){
317     
318   bool res;
319   res = set_header_fields(header, helper);
320   if (!res){
321     return false;
322   }
323
324   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header, errbuf, &errbuf_len);
325   if(ret_constr){
326     error_string.assign(&errbuf[0], errbuf_len);
327     error_string = "E2SM Indication Header Constraint failed : " + error_string;
328
329     return false;
330   }
331
332   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header, buf, *size);
333
334   if(retval.encoded == -1){
335     error_string.assign(strerror(errno));
336     error_string = "Error encoding E2N_E2SM Indication Header. Reason = " + error_string;
337     return false;
338   }
339   else if (retval.encoded > *size){
340     std::stringstream ss;
341     ss  <<"Error encoding E2SM Indication Header . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
342     error_string = ss.str();
343     return false;
344   }
345   else{
346     *size = retval.encoded;
347   }
348     
349   return true;
350 }
351
352
353 bool e2sm_indication::encode_indication_message(unsigned char *buf, size_t *size, e2sm_message_helper &helper){
354
355   set_message_fields(message, helper); 
356
357   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message, errbuf, &errbuf_len);
358   if(ret_constr){
359     error_string.assign(&errbuf[0], errbuf_len);
360     error_string = "E2SM Indication Message Constraint failed : " + error_string;
361     return false;
362   }
363
364   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message, buf, *size);
365   if(retval.encoded == -1){
366     error_string.assign(strerror(errno));
367     error_string = "Error encoding E2SM Indication Header. Reason = " + error_string;
368     return false;
369   }
370   else if (retval.encoded > *size){
371     std::stringstream ss;
372     ss  <<"Error encoding E2N_E2SM Indication Message . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
373     error_string = ss.str();
374     
375     return false;
376   }
377   else{
378     *size = retval.encoded;
379   }
380   
381   return true;
382 }
383
384
385
386 // Used when generating an indication header 
387 bool e2sm_indication::set_header_fields(E2N_E2SM_gNB_X2_indicationHeader_t *header,  e2sm_header_helper &helper){
388
389   if (header == 0){
390     error_string = "Invalid reference for E2SM Indication Header set fields";
391     return false;
392   }
393   
394   
395   header->interfaceDirection = helper.interface_direction;
396   header->interface_ID.present = E2N_Interface_ID_PR_global_gNB_ID;
397   header->interface_ID.choice.global_gNB_ID = &gNodeB_ID;
398
399
400   // to do : need to put correct code here for upding plmn id and gNodeB
401   // for now just place holders :
402   memcpy(gNodeB_ID.pLMN_Identity.buf, helper.plmn_id.c_str(), 3);
403   gNodeB_ID.pLMN_Identity.size = 3;
404   
405   memcpy(gNodeB_ID.gNB_ID.choice.gNB_ID.buf, helper.egNB_id.c_str(), 3);
406   gNodeB_ID.gNB_ID.choice.gNB_ID.size = 3;
407   
408   // we only do global gNodeB id for now, not eNodeB
409   gNodeB_ID.gNB_ID.present = E2N_GNB_ID_PR_gNB_ID;
410
411   return true;
412   
413 };
414
415
416 // used when decoding an indication header
417 bool e2sm_indication::get_header_fields(E2N_E2SM_gNB_X2_indicationHeader_t *header,  e2sm_header_helper &helper){
418
419   if (header == 0){
420     error_string = "Invalid reference for E2SM Indication header get fields";
421     return false;
422   }
423   
424   helper.interface_direction = header->interfaceDirection;
425   helper.plmn_id.assign((const char *)header->interface_ID.choice.global_gNB_ID->pLMN_Identity.buf, header->interface_ID.choice.global_gNB_ID->pLMN_Identity.size);
426   helper.egNB_id.assign((const char *)header->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.buf, header->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.size);
427   
428   // to do : add code to decipher plmn and global gnodeb from ints (since that is likely the convention for packing)
429
430   return true;
431 }
432
433
434
435 // Used when generating an indication message 
436 bool   e2sm_indication::set_message_fields(E2N_E2SM_gNB_X2_indicationMessage_t *interface_message,  e2sm_message_helper &helper){
437
438   if(interface_message == 0){
439     error_string = "Invalid reference for E2SM Indication Message set fields";
440     return false;
441   }
442
443   // interface-message is an octet string. just point it to the buffer
444   interface_message->interfaceMessage.buf = &(helper.x2ap_pdu[0]);
445   interface_message->interfaceMessage.size = helper.x2ap_pdu_size;
446
447   return true;
448   
449 };
450
451 // used when decoding an indication message
452 bool e2sm_indication::get_message_fields( E2N_E2SM_gNB_X2_indicationMessage_t *interface_message, e2sm_message_helper &helper){
453
454   
455   if(interface_message == 0){
456     error_string = "Invalid reference for E2SM Indication Message get fields";
457     return false;
458   }
459
460   // interface message is an octet string
461   helper.x2ap_pdu = interface_message->interfaceMessage.buf;;
462   helper.x2ap_pdu_size = interface_message->interfaceMessage.size;
463
464   return true;
465   
466 }
467   
468
469    
470 // initialize
471 e2sm_control::e2sm_control(void) {
472   
473   memset(&gNodeB_ID, 0, sizeof(E2N_GlobalGNB_ID_t));
474     
475   // allocate space for gNodeB id  (used for encoding)
476   gNodeB_ID.gNB_ID.choice.gNB_ID.buf = (uint8_t *)calloc(4, sizeof(uint8_t));
477   assert(gNodeB_ID.gNB_ID.choice.gNB_ID.buf != 0);
478     
479   // allocate space for plmn identity  (used for encoding)
480   gNodeB_ID.pLMN_Identity.buf = (uint8_t *) calloc(4, sizeof(uint8_t));
481   assert(gNodeB_ID.pLMN_Identity.buf != 0);
482
483   header = 0;
484   header = (E2N_E2SM_gNB_X2_controlHeader_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_controlHeader_t));
485   assert(header != 0);
486
487   message = 0;
488   message = (E2N_E2SM_gNB_X2_controlMessage_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_controlMessage_t));
489   assert(message != 0);
490 }
491   
492 e2sm_control::~e2sm_control(void){
493   mdclog_write(MDCLOG_DEBUG, "Freeing E2SM Control  object memory");
494
495   free(gNodeB_ID.gNB_ID.choice.gNB_ID.buf);
496   free(gNodeB_ID.pLMN_Identity.buf);
497   header->interface_ID.choice.global_gNB_ID = 0;
498   ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header);
499
500   message->interfaceMessage.buf = 0;
501   ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message);
502
503   mdclog_write(MDCLOG_DEBUG, "Freed E2SM Control  object memory");
504     
505 }
506   
507   
508
509 bool e2sm_control::encode_control_header(unsigned char *buf, size_t *size, e2sm_header_helper &helper){
510     
511   bool res;
512   res = set_header_fields(header, helper);
513   if (!res){
514     return false;
515   }
516
517   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header, errbuf, &errbuf_len);
518   if(ret_constr){
519     error_string.assign(&errbuf[0], errbuf_len);
520     error_string = "E2SM Control Header Constraint failed : " + error_string;
521
522     return false;
523   }
524
525   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header, buf, *size);
526
527   if(retval.encoded == -1){
528     error_string.assign(strerror(errno));
529     error_string = "Error encoding E2SM Control Header. Reason = " + error_string;
530     return false;
531   }
532   else if (retval.encoded > *size){
533     std::stringstream ss;
534     ss  <<"Error encoding E2N_E2SM Control Header . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
535     error_string = ss.str();
536     return false;
537   }
538   else{
539     *size = retval.encoded;
540   }
541     
542   return true;
543 }
544
545
546 bool e2sm_control::encode_control_message(unsigned char *buf, size_t *size, e2sm_message_helper &helper){
547
548   set_message_fields(message, helper); 
549
550   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message, errbuf, &errbuf_len);
551   if(ret_constr){
552     error_string.assign(&errbuf[0], errbuf_len);
553     error_string = "E2SM Control Message Constraint failed : " + error_string;
554     return false;
555   }
556
557   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message, buf, *size);
558   if(retval.encoded == -1){
559     error_string.assign(strerror(errno));
560     error_string = "Error encoding E2SM Control Message. Reason = " + error_string;
561     return false;
562   }
563   else if (retval.encoded > *size){
564     std::stringstream ss;
565     ss  <<"Error encoding E2SM Control Message . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
566     error_string = ss.str();
567     
568     return false;
569   }
570   else{
571     *size = retval.encoded;
572   }
573   
574   return true;
575 }
576
577
578
579 // Used when generating an indication header 
580 bool e2sm_control::set_header_fields(E2N_E2SM_gNB_X2_controlHeader_t *header,  e2sm_header_helper &helper){
581
582   if (header == 0){
583     error_string = "Invalid reference for E2SM Control Header set fields";
584     return false;
585   }
586   
587   
588   header->interfaceDirection = helper.interface_direction;
589   header->interface_ID.present = E2N_Interface_ID_PR_global_gNB_ID;
590   header->interface_ID.choice.global_gNB_ID = &gNodeB_ID;
591
592
593   // to do : need to put correct code here for upding plmn id and gNodeB
594   // for now just place holders :
595   memcpy(gNodeB_ID.pLMN_Identity.buf, helper.plmn_id.c_str(), 3);
596   gNodeB_ID.pLMN_Identity.size = 3;
597   
598   memcpy(gNodeB_ID.gNB_ID.choice.gNB_ID.buf, helper.egNB_id.c_str(), 3);
599   gNodeB_ID.gNB_ID.choice.gNB_ID.size = 3;
600   
601   // we only do global gNodeB id for now, not eNodeB
602   gNodeB_ID.gNB_ID.present = E2N_GNB_ID_PR_gNB_ID;
603
604   return true;
605   
606 };
607
608
609 // used when decoding an indication header
610 bool e2sm_control::get_header_fields(E2N_E2SM_gNB_X2_controlHeader_t *header,  e2sm_header_helper &helper){
611
612   if (header == 0){
613     error_string = "Invalid reference for E2SM Control header get fields";
614     return false;
615   }
616   
617   helper.interface_direction = header->interfaceDirection;
618   helper.plmn_id.assign((const char *)header->interface_ID.choice.global_gNB_ID->pLMN_Identity.buf, header->interface_ID.choice.global_gNB_ID->pLMN_Identity.size);
619   helper.egNB_id.assign((const char *)header->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.buf, header->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.size);
620   
621   // to do : add code to decipher plmn and global gnodeb from ints (since that is likely the convention for packing)
622
623   return true;
624 }
625
626
627
628 // Used when generating an indication message 
629 bool   e2sm_control::set_message_fields(E2N_E2SM_gNB_X2_controlMessage_t *interface_message,  e2sm_message_helper &helper){
630
631   if(interface_message == 0){
632     error_string = "Invalid reference for E2SM Control Message set fields";
633     return false;
634   }
635
636   // interface-message is an octet string. just point it to the buffer
637   interface_message->interfaceMessage.buf = &(helper.x2ap_pdu[0]);
638   interface_message->interfaceMessage.size = helper.x2ap_pdu_size;
639
640   return true;
641   
642 };
643
644 // used when decoding an indication message
645 bool e2sm_control::get_message_fields( E2N_E2SM_gNB_X2_controlMessage_t *interface_message, e2sm_message_helper &helper){
646
647   
648   if(interface_message == 0){
649     error_string = "Invalid reference for E2SM Control Message get fields";
650     return false;
651   }
652
653   // interface message is an octet string
654   helper.x2ap_pdu = interface_message->interfaceMessage.buf;;
655   helper.x2ap_pdu_size = interface_message->interfaceMessage.size;
656
657   return true;
658   
659 }
660