e2sm/wrapper.c

   1 #include <errno.h>
   2 #include "wrapper.h"
   3 #include "OCTET_STRING.h"
   4
   5 //ssize_t e2sm_encode_ric_control_header(void *buffer, size_t buf_size,struct uEID *inUEID,long f1AP[1],long e1AP[1],long ricControlStyleType, long ricControlActionID)
   6 ssize_t e2sm_encode_ric_control_header(void *buffer, size_t buf_size,struct uEID *inUEID,long f1AP[],size_t f1AP_len,long e1AP[],size_t e1Ap_len,long ricControlStyleType, long ricControlActionID, void* plmnId, size_t  plmnIdSize)
   7 {
   8         fprintf(stderr,"e2SM wrapper function Entered\n");
   9         fprintf(stderr,"plmn Size = %ld and aMFRegionID Size = %ld and aMFSetID_size = %ld and aMFPointer_size = %ld \n", inUEID->pLMNIdentity_size,inUEID->aMFRegionID_size,inUEID->aMFSetID_size,inUEID->aMFPointer_size);
  10
  11         E2SM_RC_ControlHeader_t *controlHeaderIE = (E2SM_RC_ControlHeader_t *)calloc(1, sizeof(E2SM_RC_ControlHeader_t));
  12         if(!controlHeaderIE)
  13         {
  14                 fprintf(stderr, "alloc E2SM_RC_ControlHeader failed\n");
  15                    return -1;
  16         }
  17
  18         controlHeaderIE->ric_controlHeader_formats.present = E2SM_RC_ControlHeader__ric_controlHeader_formats_PR_controlHeader_Format1;
  19         E2SM_RC_ControlHeader_Format1_t  *controlHeader_Fmt1 = (E2SM_RC_ControlHeader_Format1_t *)calloc(1, sizeof(E2SM_RC_ControlHeader_Format1_t));
  20         if(!controlHeader_Fmt1)
  21         {
  22                 fprintf(stderr, "alloc E2SM_RC_ControlHeader failed\n");
  23                 return -1;
  24         }
  25
  26         controlHeader_Fmt1->ueID.present = UEID_PR_gNB_UEID;
  27         controlHeader_Fmt1->ueID.choice.gNB_UEID = (UEID_GNB_t *)calloc(1,sizeof(UEID_GNB_t));
  28         if(! controlHeader_Fmt1->ueID.choice.gNB_UEID)
  29         {
  30                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
  31                 fprintf(stderr, "alloc gNB_UEID failed\n");
  32                 return -1;
  33         }
  34
  35         asn_long2INTEGER(&controlHeader_Fmt1->ueID.choice.gNB_UEID->amf_UE_NGAP_ID,inUEID->amf_UE_NGAP_Id);
  36
  37         fprintf(stderr, "e2sm_encode_ric_control_header amf_UE_NGAP_ID encoded \n");
  38
  39         //OCTET_STRING_fromBuf(&controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.pLMNIdentity,inUEID->pLMNIdentity, inUEID->pLMNIdentity_size);
  40
  41         OCTET_STRING_fromBuf(&controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.pLMNIdentity, plmnId,plmnIdSize);
  42         fprintf(stderr, "e2smrc_encode_ric_control_header pLMNIdentity encoded \n");
  43
  44         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFRegionID.buf = (uint8_t*)calloc(1,inUEID->aMFRegionID_size);
  45         if(!controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFRegionID.buf)
  46         {
  47                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
  48                 fprintf(stderr, "alloc aMFRegionID Value failed\n");
  49                 return -1;
  50         }
  51         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFRegionID.size = inUEID->aMFRegionID_size;
  52         //controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFRegionID.buf[0] = inUEID->aMFRegionID && 0XFF;
  53         //controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFRegionID.buf[0] = *(inUEID->aMFRegionID ) & 0XFF;
  54         memcpy(controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFRegionID.buf,inUEID->aMFRegionID,inUEID->aMFRegionID_size);
  55
  56         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.buf = (uint8_t*)calloc(1, inUEID->aMFSetID_size);
  57         if(!controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.buf)
  58         {
  59                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
  60                 fprintf(stderr, "alloc aMFSetID Value failed\n");
  61                 return -1;
  62         }
  63         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.size = inUEID->aMFSetID_size;
  64         //controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.buf[0] = (inUEID->aMFSetID && 0xFF00) >> 8;
  65         //controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.buf[1] = inUEID->aMFSetID && 0XFF00 && 0X00FF;
  66         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.buf[0] = (*(inUEID->aMFSetID) & 0xFFC0) >> 8;
  67         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFSetID.bits_unused = 6;
  68
  69
  70         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFPointer.buf = (uint8_t*)calloc(1, inUEID->aMFPointer_size);
  71         if(!controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFPointer.buf)
  72         {
  73                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
  74                 fprintf(stderr, "alloc aMFPointer Value failed\n");
  75                 return -1;
  76         }
  77
  78         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFPointer.size = inUEID->aMFPointer_size;
  79         //controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFPointer.buf[0] = inUEID->aMFPointer && 0XFF;
  80         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFPointer.buf[0] = (*(inUEID->aMFPointer) & 0xFC) >> 2;
  81         controlHeader_Fmt1->ueID.choice.gNB_UEID->guami.aMFPointer.bits_unused = 2;
  82
  83
  84         controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_UE_F1AP_ID_List = (UEID_GNB_CU_F1AP_ID_List_t *)calloc(1,sizeof(UEID_GNB_CU_F1AP_ID_List_t));
  85         if(! controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_UE_F1AP_ID_List)
  86         {
  87                 fprintf(stderr, "alloc gNB_CU_CP_UE_E1AP_ID_list failed\n");
  88                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
  89                 return -1;
  90         }
  91         /*
  92         UEID_GNB_CU_CP_F1AP_ID_Item_t *F1AP_ID_Item = (UEID_GNB_CU_CP_F1AP_ID_Item_t *)calloc (1, sizeof(UEID_GNB_CU_CP_F1AP_ID_Item_t ));
  93         if(! F1AP_ID_Item)
  94         {
  95                 fprintf(stderr, "alloc UEID_GNB_CU_CP_F1AP_ID_Item failed\n");
  96                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
  97                 return -1;
  98         }
  99         */
 100         //f1AP is an array of data
 101         //int n = sizeof(f1AP)/sizeof(long int);
 102         for(int i =0; i < f1AP_len; i++)
 103         {
 104                 UEID_GNB_CU_CP_F1AP_ID_Item_t *F1AP_ID_Item = (UEID_GNB_CU_CP_F1AP_ID_Item_t *)calloc (1, sizeof(UEID_GNB_CU_CP_F1AP_ID_Item_t ));
 105                 if(! F1AP_ID_Item)
 106                 {
 107                         fprintf(stderr, "alloc UEID_GNB_CU_CP_F1AP_ID_Item failed\n");
 108                         ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
 109                         return -1;
 110                 }
 111                 F1AP_ID_Item->gNB_CU_UE_F1AP_ID  = f1AP[i];
 112                 fprintf(stderr, "F1AP_id %d =%lu\n",i,*((unsigned long *) F1AP_id +i ));
 113                 ASN_SEQUENCE_ADD(&controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_UE_F1AP_ID_List->list,F1AP_ID_Item);
 114         }
 115         //F1AP_ID_Item->gNB_CU_UE_F1AP_ID  = f1AP[0];
 116         //ASN_SEQUENCE_ADD(&controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_UE_F1AP_ID_List->list,F1AP_ID_Item);
 117
 118
 119
 120         controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_CP_UE_E1AP_ID_List = (UEID_GNB_CU_CP_E1AP_ID_List_t *)calloc(1,sizeof(UEID_GNB_CU_CP_E1AP_ID_List_t));
 121
 122         if(! controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_CP_UE_E1AP_ID_List)
 123         {
 124                 fprintf(stderr, "alloc gNB_CU_CP_UE_E1AP_ID_list failed\n");
 125                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
 126                 return -1;
 127         }
 128
 129
 130         //n = sizeof(e1AP)/sizeof(long int);
 131         for(int i =0; i < e1Ap_len; i++)
 132         {
 133                 UEID_GNB_CU_CP_E1AP_ID_Item_t *E1AP_ID_Item = (UEID_GNB_CU_CP_E1AP_ID_Item_t *)calloc (1, sizeof(UEID_GNB_CU_CP_E1AP_ID_Item_t ));
 134                 if(! E1AP_ID_Item)
 135                 {
 136                         fprintf(stderr, "alloc UEID_GNB_CU_CP_E1AP_ID_Item failed\n");
 137                         ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
 138                         return -1;
 139
 140                 }
 141                 E1AP_ID_Item->gNB_CU_CP_UE_E1AP_ID = e1AP[i];
 142                 ASN_SEQUENCE_ADD(&controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_CP_UE_E1AP_ID_List->list,E1AP_ID_Item);
 143         //E1AP_ID_Item->gNB_CU_CP_UE_E1AP_ID = (*(unsigned long *) E1AP_id) ;
 144         //ASN_SEQUENCE_ADD(&controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_CP_UE_E1AP_ID_List->list,E1AP_ID_Item);
 145         }
 146
 147
 148          /*UEID_GNB_CU_CP_E1AP_ID_Item_t *E1AP_ID_Item = (UEID_GNB_CU_CP_E1AP_ID_Item_t *)calloc (1, sizeof(UEID_GNB_CU_CP_E1AP_ID_Item_t ));
 149          if(! E1AP_ID_Item)
 150          {
 151                 fprintf(stderr, "alloc UEID_GNB_CU_CP_E1AP_ID_Item failed\n");
 152                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
 153                 return -1;
 154
 155          }
 156          E1AP_ID_Item->gNB_CU_CP_UE_E1AP_ID = e1AP[0];
 157          ASN_SEQUENCE_ADD(&controlHeader_Fmt1->ueID.choice.gNB_UEID->gNB_CU_CP_UE_E1AP_ID_List->list,E1AP_ID_Item);
 158         */
 159         controlHeader_Fmt1->ric_Style_Type = ricControlStyleType;
 160         controlHeader_Fmt1->ric_ControlAction_ID = ricControlActionID;
 161
 162         controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1 = controlHeader_Fmt1;
 163
 164         fprintf(stderr, "Manju string %s\n",controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->amf_UE_NGAP_ID.buf) ;
 165
 166         fprintf(stderr, "Manju string %s\n",controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->guami.pLMNIdentity.buf);
 167
 168
 169         fprintf(stderr, "Manju string %s\n",controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->guami.aMFRegionID.buf);
 170
 171 fprintf(stderr, "Manju string %s\n",controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->guami.aMFSetID.buf);
 172
 173 fprintf(stderr, "Manju string %s\n",controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->guami.aMFPointer.buf);
 174
 175 fprintf(stderr, "Manju string %lu\n",(**(controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->gNB_CU_CP_UE_E1AP_ID_List->list.array)).gNB_CU_CP_UE_E1AP_ID);
 176
 177 fprintf(stderr, "Manju string %lu\n",(**(controlHeaderIE->ric_controlHeader_formats.choice.controlHeader_Format1->ueID.choice.gNB_UEID->gNB_CU_UE_F1AP_ID_List->list.array)).gNB_CU_UE_F1AP_ID);
 178
 179
 180         fprintf(stderr, "showing xer of asn_DEF_E2SM_RC_ControlHeader data\n");
 181         xer_fprint(stderr, &asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
 182         fprintf(stderr, "\n");
 183         fprintf(stderr, "After xer of asn_DEF_E2SM_RC_ControlHeader data\n");
 184
 185         asn_enc_rval_t encode_result;
 186         encode_result = aper_encode_to_buffer(&asn_DEF_E2SM_RC_ControlHeader, NULL, controlHeaderIE, buffer, buf_size);
 187
 188
 189         ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlHeader, controlHeaderIE);
 190         if(encode_result.encoded == -1)
 191         {
 192                 fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
 193                 return -1;
 194         }
 195         else
 196         {
 197                return encode_result.encoded;
 198         }
 199 }
 200
 201 ssize_t e2sm_encode_nrcgi(NR_CGI_t *nr_cgi, void* plmnIdValue, size_t  plmnId_size,ulong lNRCellId, uint8_t* buffer, size_t buf_size)
 202 {
 203         nr_cgi = (NR_CGI_t*)calloc(1, sizeof(NR_CGI_t));
 204         if(!nr_cgi) {
 205                 fprintf(stderr, "e2src_encode_nrcgi alloc nr_cgi failed \n");
 206                 return -1;
 207         }
 208         OCTET_STRING_fromBuf(&nr_cgi->pLMNIdentity,plmnIdValue, plmnId_size);
 209         //fprintf(stderr, "encodec Plmn Id = %s  plmnIdValue %s and lNRCellId = %lu \n", nr_cgi->pLMNIdentity, plmnIdValue,lNRCellId);
 210         //fprintf(stderr, "encodec Plmn Id = %s  and lNRCellId = %d \n", nr_cgi->pLMNIdentity,plmnIdValue,lNRCellId);
 211         BIT_STRING_t *nr_cell_id = (BIT_STRING_t*)calloc(1, sizeof(BIT_STRING_t));
 212            if(nr_cell_id)
 213            {
 214                nr_cell_id->buf = (uint8_t*)calloc(1,5);
 215                if(nr_cell_id->buf)
 216                {
 217                    nr_cell_id->size = 5;
 218                    nr_cell_id->buf[0] = ((lNRCellId & 0X0FF0000000) >> 28);
 219                    nr_cell_id->buf[1] = ((lNRCellId & 0X000FF00000) >> 20);
 220                    nr_cell_id->buf[2] = ((lNRCellId & 0X00000FF000) >> 12);
 221                    nr_cell_id->buf[3] = ((lNRCellId & 0X0000000FF0) >> 4);
 222                    nr_cell_id->buf[4] = (lNRCellId & 0X000000000F) << 4;
 223                    nr_cell_id->bits_unused = 4;
 224
 225                    nr_cgi->nRCellIdentity = *nr_cell_id;
 226                }
 227            }
 228
 229           fprintf(stderr, "showing xer of asn_DEF_NR_CGI NR_CGI_t data\n");
 230           xer_fprint(stderr, &asn_DEF_NR_CGI, nr_cgi);
 231
 232            asn_enc_rval_t encode_result = aper_encode_to_buffer(&asn_DEF_NR_CGI, NULL, nr_cgi, buffer, buf_size);
 233
 234            if(encode_result.encoded != -1)
 235            {
 236                fprintf(stderr, "nr_cgi encodedi length = %zd \n", encode_result.encoded) ;
 237                return encode_result.encoded;
 238            }
 239            else
 240            {
 241                fprintf(stderr, "nr_cgi encode failed =%zd \n", encode_result.encoded) ;
 242                return -1 ;
 243            }
 244 }
 245
 246 ssize_t e2sm_encode_ric_control_message(void *buffer, size_t buf_size, long targetPrimaryCell,
 247                         long targetCell, long nrOrEUtraCell, long nrCGIOrECGI, void* ranParameterValue, size_t  ranParameterValue_size)
 248 {
 249         fprintf(stderr, "e2sm_encode_ric_control_message \n") ;
 250         //NR_CGI_t *nr_cgi = NULL;
 251         //uint8_t nrcgiBuf[buf_size];
 252         //ssize_t nrcgiBuf_size,nrcgiLen;
 253
 254
 255         E2SM_RC_ControlMessage_t *e2smrcRcControlMsg = (E2SM_RC_ControlMessage_t*)calloc(1, sizeof(E2SM_RC_ControlMessage_t));
 256         if(!e2smrcRcControlMsg) {
 257             fprintf(stderr, "alloc E2SM_ControlMessage_t failed\n");
 258         return -1;
 259         }
 260          e2smrcRcControlMsg->ric_controlMessage_formats.present = E2SM_RC_ControlMessage__ric_controlMessage_formats_PR_controlMessage_Format1;
 261
 262         E2SM_RC_ControlMessage_Format1_t *e2smrcRcControlFormat1 = (E2SM_RC_ControlMessage_Format1_t*)calloc(1, sizeof(E2SM_RC_ControlMessage_Format1_t));
 263         if(!e2smrcRcControlFormat1) {
 264                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 265                 fprintf(stderr, "alloc E2SM_ControlMessage_Format1_t failed\n");
 266                 return -1;
 267         }
 268         // Start Target Primary Cell
 269         E2SM_RC_ControlMessage_Format1_Item_t *ranParameterItem1 = (E2SM_RC_ControlMessage_Format1_Item_t *) calloc(1,sizeof(
 270                                                                                 E2SM_RC_ControlMessage_Format1_Item_t));
 271         if(!ranParameterItem1) {
 272                 fprintf(stderr, "alloc RANParameter_Item_t1 failed\n");
 273                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 274                 return -1;
 275         }
 276
 277         ranParameterItem1->ranParameter_ID = targetPrimaryCell;     // Target Primary Cell ID value = 1
 278         ranParameterItem1->ranParameter_valueType.present = RANParameter_ValueType_PR_ranP_Choice_Structure;
 279
 280         RANParameter_ValueType_Choice_Structure_t *ranParameterStructure1 = (RANParameter_ValueType_Choice_Structure_t*)calloc(1, sizeof(RANParameter_ValueType_Choice_Structure_t));
 281         if(!ranParameterStructure1)
 282         {
 283                 fprintf(stderr, "alloc RANParameter_STRUCTURE_t1 failed\n");
 284                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 285                 return -1;
 286         }
 287
 288         fprintf(stderr, "targetPrimaryCell encoded \n");
 289
 290          // Start Target Cell
 291         RANParameter_STRUCTURE_Item_t *ranParameterItem2 = (RANParameter_STRUCTURE_Item_t *)calloc(1,sizeof(RANParameter_STRUCTURE_Item_t));
 292
 293         if(!ranParameterItem2)
 294         {
 295
 296                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 297                 fprintf(stderr, "alloc RANParameter_Item_t2 failed\n");
 298                 return -1;
 299         }
 300
 301         ranParameterItem2->ranParameter_ID = targetCell;    // Target Cell ID value = 2
 302
 303         RANParameter_ValueType_Choice_Structure_t *ranParameterStructure2 = (RANParameter_ValueType_Choice_Structure_t*)calloc(1, sizeof(struct RANParameter_ValueType_Choice_Structure));
 304         if(!ranParameterStructure2)
 305         {
 306                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 307                 fprintf(stderr, "alloc RANParameter_STRUCTURE_t2 failed\n");
 308                 return -1;
 309         }
 310
 311         fprintf(stderr, "targetPrimaryCellId Value encoded \n");
 312
 313         // Start NR Cell  (or E-UTRA Cell)
 314          RANParameter_STRUCTURE_Item_t *ranParameterItem3 = (RANParameter_STRUCTURE_Item_t*)calloc(1,sizeof(RANParameter_STRUCTURE_Item_t));
 315         if(!ranParameterItem3)
 316         {
 317                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 318                 fprintf(stderr, "alloc RANParameter_Item_t3 failed\n");
 319                 return -1;
 320         }
 321
 322         ranParameterItem3->ranParameter_ID = nrOrEUtraCell; // NR Cell ID (or E-UTRA Cell ID) value =
 323
 324         RANParameter_ValueType_Choice_Structure_t *ranParameterStructure3 = (struct RANParameter_ValueType_Choice_Structure*)calloc(1, sizeof(struct RANParameter_ValueType_Choice_Structure));
 325         if(!ranParameterStructure3)
 326         {
 327                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 328                 fprintf(stderr, "alloc RANParameter_Item_t3 failed\n");
 329                 return -1;
 330         }
 331         fprintf(stderr, " NR Cell ID  Value encoded \n");
 332
 333         // Start NR CGI (or ECGI)
 334         RANParameter_STRUCTURE_Item_t *ranParameterItem4 = (RANParameter_STRUCTURE_Item_t *) calloc(1,sizeof(
 335                                                                         RANParameter_STRUCTURE_Item_t));
 336         if(!ranParameterItem4)
 337         {
 338                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 339                 fprintf(stderr, "alloc RANParameter_Item_t4 failed\n");
 340                 return -1;
 341         }
 342
 343         ranParameterItem4->ranParameter_ID = nrCGIOrECGI;   // NR CGI ID (or ECGI ID) value =
 344
 345         ranParameterItem4->ranParameter_valueType = (RANParameter_ValueType_t*)calloc(1,sizeof(RANParameter_ValueType_t));
 346         if(!ranParameterItem4->ranParameter_valueType)
 347         {
 348                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 349                 fprintf(stderr, "alloc ranParameterItem4->ranParameter_valueType failed\n");
 350                 return -1;
 351         }
 352
 353         ranParameterItem4->ranParameter_valueType->present = RANParameter_ValueType_PR_ranP_Choice_ElementFalse;
 354         ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse = (RANParameter_ValueType_Choice_ElementFalse_t *)calloc(1, sizeof(RANParameter_ValueType_Choice_ElementFalse_t));
 355         if(!ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse)
 356         {
 357                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 358                 fprintf(stderr, "alloc RANParameter_Item_t4 failed\n");
 359                 return -1;
 360         }
 361
 362         ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse->ranParameter_value = (RANParameter_Value_t *)calloc(1, sizeof(RANParameter_Value_t));
 363         if(!ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse->ranParameter_value)
 364         {
 365                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 366                 fprintf(stderr, "alloc ranParameter_value failed\n");
 367                 return -1;
 368         }
 369         ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse->ranParameter_value->present = RANParameter_Value_PR_valueOctS;
 370         OCTET_STRING_fromBuf(&ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse->ranParameter_value->choice.valueOctS,ranParameterValue, ranParameterValue_size);
 371
 372         /*
 373         fprintf(stderr, "Target Plmn Id = %s ranParameterValue and lNRCellId = %lu \n", ranParameterValue,lNRCellId);
 374         nrcgiLen = e2sm_encode_nrcgi(nr_cgi, ranParameterValue, ranParameterValue_size, lNRCellId,nrcgiBuf,nrcgiBuf_size);
 375         if(nrcgiLen == -1 )
 376         {
 377                  fprintf(stderr,"e2srmc_encode_nrcgi failed \n");
 378                 return nrcgiLen;
 379         }
 380         OCTET_STRING_fromBuf(&ranParameterItem4->ranParameter_valueType->choice.ranP_Choice_ElementFalse->ranParameter_value->choice.valueOctS,nrcgiBuf,nrcgiLen);
 381         */
 382         fprintf(stderr, " NR CGI encoded \n");
 383
 384         ranParameterStructure3->ranParameter_Structure = (RANParameter_STRUCTURE_t*)calloc(1,sizeof(RANParameter_STRUCTURE_t));
 385         if(!ranParameterStructure3->ranParameter_Structure)
 386         {
 387                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 388                 fprintf(stderr, "alloc ranParameterStructure3->ranParameter_Structure  failed\n");
 389                 return -1;
 390         }
 391
 392         ranParameterStructure3->ranParameter_Structure->sequence_of_ranParameters = (struct RANParameter_STRUCTURE__sequence_of_ranParameters*)calloc(1,sizeof(struct RANParameter_STRUCTURE__sequence_of_ranParameters));
 393         if(!ranParameterStructure3->ranParameter_Structure->sequence_of_ranParameters)
 394         {
 395                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 396                 fprintf(stderr, "alloc ranParameterStructure3->ranParameter_Structure->sequence_of_ranParameters failed\n");
 397                 return -1;
 398         }
 399
 400
 401
 402         ASN_SEQUENCE_ADD(&ranParameterStructure3->ranParameter_Structure->sequence_of_ranParameters->list, ranParameterItem4);   // NR CGI (or ECGI)
 403         ranParameterItem3->ranParameter_valueType = (RANParameter_ValueType_t*)calloc(1,sizeof(RANParameter_ValueType_t));
 404         if(!ranParameterItem3->ranParameter_valueType)
 405         {
 406                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 407                 fprintf(stderr, "alloc ranParameterItem3->ranParameter_valueType failed\n");
 408                 return -1;
 409         }
 410         ranParameterItem3->ranParameter_valueType->present = RANParameter_ValueType_PR_ranP_Choice_Structure;
 411         ranParameterItem3->ranParameter_valueType->choice.ranP_Choice_Structure = ranParameterStructure3; // NR Cell  (or E-UTRA Cell)
 412         fprintf(stderr, " ranParameterStructure3 encoded \n");
 413
 414         ranParameterStructure2->ranParameter_Structure = (RANParameter_STRUCTURE_t*)calloc(1,sizeof(RANParameter_STRUCTURE_t));
 415         if(!ranParameterStructure2->ranParameter_Structure)
 416         {
 417                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 418                 fprintf(stderr, "alloc ranParameterStructure2->ranParameter_Structure  failed\n");
 419                 return -1;
 420         }
 421
 422         ranParameterStructure2->ranParameter_Structure->sequence_of_ranParameters = (struct RANParameter_STRUCTURE__sequence_of_ranParameters*)calloc(1,sizeof(struct RANParameter_STRUCTURE__sequence_of_ranParameters));
 423         if(!ranParameterStructure2->ranParameter_Structure->sequence_of_ranParameters)
 424         {
 425                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 426                 fprintf(stderr, "alloc ranParameterStructure3->ranParameter_Structure->sequence_of_ranParameters failed\n");
 427                 return -1;
 428         }
 429
 430         ASN_SEQUENCE_ADD(&ranParameterStructure2->ranParameter_Structure->sequence_of_ranParameters->list, ranParameterItem3);   // NR Cell  (or E-UTRA Cell)
 431         ranParameterItem2->ranParameter_valueType = (RANParameter_ValueType_t*)calloc(1,sizeof(RANParameter_ValueType_t));
 432         if(!ranParameterItem2->ranParameter_valueType)
 433         {
 434                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 435                 fprintf(stderr, "alloc ranParameterItem2->ranParameter_valueType failed\n");
 436                 return -1;
 437         }
 438         ranParameterItem2->ranParameter_valueType->present = RANParameter_ValueType_PR_ranP_Choice_Structure;
 439         ranParameterItem2->ranParameter_valueType->choice.ranP_Choice_Structure = ranParameterStructure2; // Target Cell
 440         fprintf(stderr, " ranParameterStructure2 encoded \n");
 441
 442         ranParameterStructure1->ranParameter_Structure = (RANParameter_STRUCTURE_t*)calloc(1,sizeof(RANParameter_STRUCTURE_t));
 443         if(!ranParameterStructure1->ranParameter_Structure)
 444         {
 445                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 446                 fprintf(stderr, "alloc ranParameterStructure1->ranParameter_Structure  failed\n");
 447                 return -1;
 448         }
 449
 450         ranParameterStructure1->ranParameter_Structure->sequence_of_ranParameters = (struct RANParameter_STRUCTURE__sequence_of_ranParameters*)calloc(1,sizeof(struct RANParameter_STRUCTURE__sequence_of_ranParameters));
 451         if(!ranParameterStructure1->ranParameter_Structure->sequence_of_ranParameters)
 452         {
 453                 ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 454                 fprintf(stderr, "alloc ranParameterStructure1->ranParameter_Structure->sequence_of_ranParameters failed\n");
 455                 return -1;
 456         }
 457         fprintf(stderr, " ranParameterStructure1 encoded \n");
 458
 459         ASN_SEQUENCE_ADD(&ranParameterStructure1->ranParameter_Structure->sequence_of_ranParameters->list, ranParameterItem2);   // Target Cell
 460         ranParameterItem1->ranParameter_valueType.choice.ranP_Choice_Structure = ranParameterStructure1; // Target Primary Cell
 461
 462         ASN_SEQUENCE_ADD(&e2smrcRcControlFormat1->ranP_List.list, ranParameterItem1); // Target Primary Cell
 463         e2smrcRcControlMsg->ric_controlMessage_formats.choice.controlMessage_Format1 = e2smrcRcControlFormat1;
 464
 465
 466         fprintf(stderr, "showing xer of asn_DEF_E2SM_RC_ControlMessage data\n");
 467         xer_fprint(stderr, &asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 468         fprintf(stderr, "\n");
 469         fprintf(stderr, "After xer of asn_DEF_E2SM_RC_ControlMessage data\n");
 470
 471         asn_enc_rval_t encode_result;
 472         encode_result = aper_encode_to_buffer(&asn_DEF_E2SM_RC_ControlMessage, NULL, e2smrcRcControlMsg, buffer, buf_size);
 473         ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlMessage, e2smrcRcControlMsg);
 474         fprintf(stderr, "encoded length = %ld \n", encode_result.encoded);
 475         if(encode_result.encoded == -1)
 476         {
 477                 fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
 478                 return -1;
 479         }
 480         else
 481         {
 482                 return encode_result.encoded;
 483         }
 484 }
 485
 486
 487 E2SM_RC_ControlOutcome_t* e2sm_decode_ric_call_process_outcome(void *buffer, size_t buf_size)
 488 {
 489         fprintf(stderr, "e2sm_decode_ric_call_process_outcome Enter \n");
 490         asn_dec_rval_t decode_result;
 491         E2SM_RC_ControlOutcome_t* controlOutcome = NULL;
 492         decode_result = aper_decode_complete(NULL, &asn_DEF_E2SM_RC_ControlOutcome, (void **)&controlOutcome, buffer, buf_size);
 493         if(decode_result.code == RC_OK) {
 494                 xer_fprint(stdout, &asn_DEF_E2SM_RC_ControlOutcome, controlOutcome);
 495                 return controlOutcome;
 496         }
 497         else {
 498         ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlOutcome, controlOutcome);
 499         return NULL;
 500         }
 501 }
 502
 503 void e2sm_free_ric_call_process_outcome(E2SM_RC_ControlOutcome_t* controlOutcome) {
 504         ASN_STRUCT_FREE(asn_DEF_E2SM_RC_ControlOutcome, controlOutcome);
 505 }