e2ap/libe2ap_wrapper/E2AP_tests.c

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   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, software
  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
  21 #if DEBUG
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "Cause.h"
  27 #include "E2AP_if.h"
  28
  29 const size_t cDataBufferSize = 2048;
  30
  31 //////////////////////////////////////////////////////////////////////
  32 bool TestRICSubscriptionRequest() {
  33
  34     RICSubscriptionRequest_t ricSubscriptionRequest;
  35
  36     // RICrequestID
  37     ricSubscriptionRequest.ricRequestID.ricRequestorID = 20206;
  38     ricSubscriptionRequest.ricRequestID.ricInstanceID = 0;
  39
  40     // RANfunctionID
  41     ricSubscriptionRequest.ranFunctionID = 3;
  42
  43     // RICsubscriptionDetails
  44     // RICeventTriggerDefinition
  45     ricSubscriptionRequest.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength = 4;
  46     ricSubscriptionRequest.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data[0] = 11;
  47     ricSubscriptionRequest.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data[1] = 22;
  48     ricSubscriptionRequest.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data[2] = 33;
  49     ricSubscriptionRequest.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data[3] = 44;
  50
  51     // RICactions-ToBeSetup-List
  52     ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = 16;  //1..16
  53     uint64_t index = 0;
  54     while (index < ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength) {
  55
  56         // RICactionID
  57         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID = index;
  58
  59         // RICactionType
  60         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType = RICActionType_report; //RICActionType_policy;
  61
  62         // RICactionDefinition, OPTIONAL.
  63         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = true;  // E2AP
  64         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength = 2;
  65         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data[0] = 1;
  66         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data[1] = 2;
  67
  68         // RICsubsequentAction, OPTIONAL
  69         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = true;  // E2AP
  70         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType = RICSubsequentActionType_Continue;
  71         ricSubscriptionRequest.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait = RICTimeToWait_zero;
  72         index++;
  73     }
  74
  75     printRICSubscriptionRequest(&ricSubscriptionRequest);
  76
  77     uint64_t logBufferSize = 1024;
  78     char logBuffer[logBufferSize];
  79     uint64_t dataBufferSize = cDataBufferSize;
  80     byte dataBuffer[dataBufferSize];
  81     if (packRICSubscriptionRequest(&dataBufferSize, dataBuffer, logBuffer, &ricSubscriptionRequest) == e2err_OK)
  82     {
  83         memset(&ricSubscriptionRequest,0, sizeof (RICSubscriptionRequest_t));
  84         uint64_t returnCode;
  85         E2MessageInfo_t messageInfo;
  86         e2ap_pdu_ptr_t* pE2AP_PDU = unpackE2AP_pdu(dataBufferSize, dataBuffer, logBuffer, &messageInfo);
  87         if (pE2AP_PDU != 0) {
  88             if (messageInfo.messageType == cE2InitiatingMessage) {
  89                 if (messageInfo.messageId == cRICSubscriptionRequest) {
  90                     if ((returnCode = getRICSubscriptionRequestData(pE2AP_PDU, &ricSubscriptionRequest)) == e2err_OK) {
  91                         printRICSubscriptionRequest(&ricSubscriptionRequest);
  92                         return true;
  93                     }
  94                     else
  95                         printf("Error in getRICSubscriptionRequestData. ReturnCode = %s",getE2ErrorString(returnCode));
  96                 }
  97                 else
  98                     printf("Not RICSubscriptionRequest\n");
  99             }
 100             else
 101                 printf("Not InitiatingMessage\n");
 102         }
 103         else
 104             printf("%s",logBuffer);
 105     }
 106     else
 107         printf("%s",logBuffer);
 108
 109     return false;
 110 }
 111
 112 //////////////////////////////////////////////////////////////////////
 113 bool TestRICSubscriptionResponse() {
 114
 115     RICSubscriptionResponse_t ricSubscriptionResponse;
 116
 117     // RICrequestID
 118     ricSubscriptionResponse.ricRequestID.ricRequestorID = 1;
 119     ricSubscriptionResponse.ricRequestID.ricInstanceID = 22;
 120
 121     // RANfunctionID
 122     ricSubscriptionResponse.ranFunctionID = 33;
 123
 124     // RICaction-Admitted-List
 125     ricSubscriptionResponse.ricActionAdmittedList.contentLength = 16;
 126     uint64_t index = 0;
 127     while (index < ricSubscriptionResponse.ricActionAdmittedList.contentLength) {
 128
 129         // RICactionID
 130         ricSubscriptionResponse.ricActionAdmittedList.ricActionID[index] = index;
 131         index++;
 132     }
 133     // RICaction-NotAdmitted-List, OPTIONAL
 134     ricSubscriptionResponse.ricActionNotAdmittedListPresent = true;
 135     ricSubscriptionResponse.ricActionNotAdmittedList.contentLength = 16;
 136     index = 0;
 137     while (index < ricSubscriptionResponse.ricActionNotAdmittedList.contentLength) {
 138
 139         // RICactionID
 140         ricSubscriptionResponse.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID = index;  //0..255
 141
 142         // Cause
 143         ricSubscriptionResponse.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService; //cCauseRICService;
 144         ricSubscriptionResponse.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal = 2;
 145         index++;
 146     }
 147
 148     printRICSubscriptionResponse(&ricSubscriptionResponse);
 149
 150     uint64_t logBufferSize = 1024;
 151     char logBuffer[logBufferSize];
 152     uint64_t dataBufferSize = cDataBufferSize;
 153     byte dataBuffer[dataBufferSize];
 154     if (packRICSubscriptionResponse(&dataBufferSize, dataBuffer, logBuffer, &ricSubscriptionResponse) == e2err_OK)
 155     {
 156         memset(&ricSubscriptionResponse,0, sizeof ricSubscriptionResponse);
 157         uint64_t returnCode;
 158         E2MessageInfo_t messageInfo;
 159         e2ap_pdu_ptr_t* pE2AP_PDU = unpackE2AP_pdu(dataBufferSize, dataBuffer, logBuffer, &messageInfo);
 160         if (pE2AP_PDU != 0) {
 161             if (messageInfo.messageType == cE2SuccessfulOutcome) {
 162                 if (messageInfo.messageId == cRICSubscriptionResponse) {
 163                     if ((returnCode = getRICSubscriptionResponseData(pE2AP_PDU, &ricSubscriptionResponse)) == e2err_OK) {
 164                         printRICSubscriptionResponse(&ricSubscriptionResponse);
 165                         return true;
 166                     }
 167                     else
 168                         printf("Error in getRICSubscriptionResponseData. ReturnCode = %s",getE2ErrorString(returnCode));
 169                 }
 170                 else
 171                     printf("Not RICSubscriptionResponse\n");
 172             }
 173             else
 174                 printf("Not SuccessfulOutcome\n");
 175         }
 176         else
 177             printf("%s",logBuffer);
 178     }
 179     else
 180         printf("%s",logBuffer);
 181     return false;
 182 }
 183
 184 //////////////////////////////////////////////////////////////////////
 185 bool TestRICSubscriptionFailure() {
 186
 187     RICSubscriptionFailure_t ricSubscriptionFailure;
 188
 189     // RICrequestID
 190     ricSubscriptionFailure.ricRequestID.ricRequestorID = 1;
 191     ricSubscriptionFailure.ricRequestID.ricInstanceID = 22;
 192
 193     // RANfunctionID
 194     ricSubscriptionFailure.ranFunctionID = 33;
 195
 196     // Cause
 197     ricSubscriptionFailure.cause.content = Cause_PR_ricService;
 198     ricSubscriptionFailure.cause.causeVal =
 199
 200     // CriticalityDiagnostics, OPTIONAL. Not used in RIC
 201     ricSubscriptionFailure.criticalityDiagnosticsPresent = false;
 202     ricSubscriptionFailure.criticalityDiagnostics.procedureCodePresent = true;
 203     ricSubscriptionFailure.criticalityDiagnostics.procedureCode = 1;
 204     ricSubscriptionFailure.criticalityDiagnostics.triggeringMessagePresent = true;
 205     ricSubscriptionFailure.criticalityDiagnostics.triggeringMessage = TriggeringMessage__initiating_message;
 206     ricSubscriptionFailure.criticalityDiagnostics.procedureCriticalityPresent = true;
 207     ricSubscriptionFailure.criticalityDiagnostics.procedureCriticality = Criticality__reject;
 208
 209     ricSubscriptionFailure.criticalityDiagnostics.iEsCriticalityDiagnosticsPresent = false;
 210     ricSubscriptionFailure.criticalityDiagnostics.criticalityDiagnosticsIELength = 256;
 211     uint16_t index2 = 0;
 212     while (index2 < ricSubscriptionFailure.criticalityDiagnostics.criticalityDiagnosticsIELength) {
 213         ricSubscriptionFailure.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iECriticality = Criticality__reject;
 214         ricSubscriptionFailure.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iE_ID = index2;
 215         ricSubscriptionFailure.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].typeOfError = TypeOfError_missing;
 216         index2++;
 217     }
 218
 219     printRICSubscriptionFailure(&ricSubscriptionFailure);
 220
 221     uint64_t logBufferSize = 1024;
 222     char logBuffer[logBufferSize];
 223     uint64_t dataBufferSize = cDataBufferSize;
 224     byte dataBuffer[dataBufferSize];
 225     if (packRICSubscriptionFailure(&dataBufferSize, dataBuffer, logBuffer, &ricSubscriptionFailure) == e2err_OK)
 226     {
 227         memset(&ricSubscriptionFailure,0, sizeof ricSubscriptionFailure);
 228         uint64_t returnCode;
 229         E2MessageInfo_t messageInfo;
 230         e2ap_pdu_ptr_t* pE2AP_PDU = unpackE2AP_pdu(dataBufferSize, dataBuffer, logBuffer, &messageInfo);
 231         if (pE2AP_PDU != 0) {
 232             if (messageInfo.messageType == cE2UnsuccessfulOutcome) {
 233                 if (messageInfo.messageId == cRICSubscriptionFailure) {
 234                     if ((returnCode = getRICSubscriptionFailureData(pE2AP_PDU, &ricSubscriptionFailure)) == e2err_OK) {
 235                         printRICSubscriptionFailure(&ricSubscriptionFailure);
 236                         return true;
 237                     }
 238                     else
 239                         printf("Error in getRICSubscriptionFailureData. ReturnCode = %s",getE2ErrorString(returnCode));
 240                 }
 241                 else
 242                     printf("Not RICSubscriptionFailure\n");
 243             }
 244             else
 245                 printf("Not UnuccessfulOutcome\n");
 246         }
 247         else
 248             printf("%s",logBuffer);
 249     }
 250     else
 251         printf("%s",logBuffer);
 252     return false;
 253 }
 254
 255 //////////////////////////////////////////////////////////////////////
 256 bool TestRICSubscriptionDeleteRequest() {
 257
 258     RICSubscriptionDeleteRequest_t ricSubscriptionDeleteRequest;
 259
 260     // RICrequestID
 261     ricSubscriptionDeleteRequest.ricRequestID.ricRequestorID = 1;
 262     ricSubscriptionDeleteRequest.ricRequestID.ricInstanceID = 22;
 263
 264      // RANfunctionID
 265    ricSubscriptionDeleteRequest.ranFunctionID = 33;
 266
 267     printRICSubscriptionDeleteRequest(&ricSubscriptionDeleteRequest);
 268
 269     uint64_t logBufferSize = 1024;
 270     char logBuffer[logBufferSize];
 271     uint64_t dataBufferSize = cDataBufferSize;
 272     byte dataBuffer[cDataBufferSize];
 273     if ((packRICSubscriptionDeleteRequest(&dataBufferSize, dataBuffer, logBuffer, &ricSubscriptionDeleteRequest)) == e2err_OK)
 274     {
 275         memset(&ricSubscriptionDeleteRequest,0, sizeof ricSubscriptionDeleteRequest);
 276         uint64_t returnCode;
 277         E2MessageInfo_t messageInfo;
 278         e2ap_pdu_ptr_t* pE2AP_PDU = unpackE2AP_pdu(dataBufferSize, dataBuffer, logBuffer, &messageInfo);
 279         if (pE2AP_PDU != 0) {
 280             if (messageInfo.messageType == cE2InitiatingMessage) {
 281                 if (messageInfo.messageId == cRICSubscriptionDeleteRequest) {
 282                     if ((returnCode = getRICSubscriptionDeleteRequestData(pE2AP_PDU, &ricSubscriptionDeleteRequest)) == e2err_OK) {
 283                         printRICSubscriptionDeleteRequest(&ricSubscriptionDeleteRequest);
 284                         return true;
 285                     }
 286                     else
 287                         printf("Error in getRICSubscriptionDeleteRequestData. ReturnCode = %s",getE2ErrorString(returnCode));
 288                 }
 289                 else
 290                     printf("Not RICSubscriptionDeleteRequest\n");
 291             }
 292             else
 293                 printf("Not InitiatingMessage\n");
 294         }
 295         else
 296             printf("%s",logBuffer);
 297     }
 298     else
 299         printf("%s",logBuffer);
 300     return false;
 301 }
 302
 303 //////////////////////////////////////////////////////////////////////
 304 bool TestRICSubscriptionDeleteResponse() {
 305
 306     RICSubscriptionDeleteResponse_t ricSubscriptionDeleteResponse;
 307
 308     // RICrequestID
 309     ricSubscriptionDeleteResponse.ricRequestID.ricRequestorID = 1;
 310     ricSubscriptionDeleteResponse.ricRequestID.ricInstanceID = 22;
 311
 312     // RANfunctionID
 313     ricSubscriptionDeleteResponse.ranFunctionID = 33;
 314
 315     printRICSubscriptionDeleteResponse(&ricSubscriptionDeleteResponse);
 316
 317     uint64_t logBufferSize = 1024;
 318     char logBuffer[logBufferSize];
 319     uint64_t dataBufferSize = cDataBufferSize;
 320     byte dataBuffer[dataBufferSize];
 321     if ((packRICSubscriptionDeleteResponse(&dataBufferSize, dataBuffer, logBuffer, &ricSubscriptionDeleteResponse)) == e2err_OK)
 322     {
 323         memset(&ricSubscriptionDeleteResponse,0, sizeof ricSubscriptionDeleteResponse);
 324         uint64_t returnCode;
 325         E2MessageInfo_t messageInfo;
 326         e2ap_pdu_ptr_t* pE2AP_PDU = unpackE2AP_pdu(dataBufferSize, dataBuffer, logBuffer, &messageInfo);
 327         if (pE2AP_PDU != 0) {
 328             if (messageInfo.messageType == cE2SuccessfulOutcome) {
 329                 if (messageInfo.messageId == cRICsubscriptionDeleteResponse) {
 330                     if ((returnCode = getRICSubscriptionDeleteResponseData(pE2AP_PDU, &ricSubscriptionDeleteResponse)) == e2err_OK) {
 331                         printRICSubscriptionDeleteResponse(&ricSubscriptionDeleteResponse);
 332                         return true;
 333                     }
 334                     else
 335                         printf("Error in getRICSubscriptionDeleteResponseData. ReturnCode = %s",getE2ErrorString(returnCode));
 336                 }
 337                 else
 338                     printf("Not RICSubscriptionDeleteResponse\n");
 339             }
 340             else
 341                 printf("Not SuccessfulOutcome\n");
 342         }
 343         else
 344             printf("%s",logBuffer);
 345     }
 346     else
 347         printf("%s",logBuffer);
 348     return false;
 349 }
 350
 351 //////////////////////////////////////////////////////////////////////
 352 bool TestRICSubscriptionDeleteFailure() {
 353
 354     RICSubscriptionDeleteFailure_t ricSubscriptionDeleteFailure;
 355
 356     // RICrequestID
 357     ricSubscriptionDeleteFailure.ricRequestID.ricRequestorID = 1;
 358     ricSubscriptionDeleteFailure.ricRequestID.ricInstanceID = 22;
 359
 360     // RANfunctionID
 361     ricSubscriptionDeleteFailure.ranFunctionID = 33;
 362
 363     // Cause
 364     ricSubscriptionDeleteFailure.cause.content = Cause_PR_ricService;//cCauseRICService;
 365     ricSubscriptionDeleteFailure.cause.causeVal = 2;
 366
 367     printRICSubscriptionDeleteFailure(&ricSubscriptionDeleteFailure);
 368
 369     uint64_t logBufferSize = 1024;
 370     char logBuffer[logBufferSize];
 371     uint64_t dataBufferSize = cDataBufferSize;
 372     byte dataBuffer[dataBufferSize];
 373     if ((packRICSubscriptionDeleteFailure(&dataBufferSize, dataBuffer, logBuffer, &ricSubscriptionDeleteFailure)) == e2err_OK)
 374     {
 375         memset(&ricSubscriptionDeleteFailure,0, sizeof ricSubscriptionDeleteFailure);
 376         uint64_t returnCode;
 377         E2MessageInfo_t messageInfo;
 378         e2ap_pdu_ptr_t* pE2AP_PDU = unpackE2AP_pdu(dataBufferSize, dataBuffer, logBuffer, &messageInfo);
 379         if (pE2AP_PDU != 0) {
 380             if (messageInfo.messageType == cE2UnsuccessfulOutcome) {
 381                 if (messageInfo.messageId == cRICsubscriptionDeleteFailure) {
 382                     if ((returnCode = getRICSubscriptionDeleteFailureData(pE2AP_PDU, &ricSubscriptionDeleteFailure)) == e2err_OK) {
 383                         printRICSubscriptionDeleteFailure(&ricSubscriptionDeleteFailure);
 384                         return true;
 385                     }
 386                     else
 387                         printf("Error in getRICSubscriptionDeleteFailureData. ReturnCode = %s",getE2ErrorString(returnCode));
 388                 }
 389                 else
 390                     printf("Not RICSubscriptionDeleteFailure\n");
 391             }
 392             else
 393                 printf("Not UnuccessfulOutcome\n");
 394         }
 395         else
 396             printf("%s",logBuffer);
 397     }
 398     else
 399         printf("%s",logBuffer);
 400     return false;
 401 }
 402
 403 //////////////////////////////////////////////////////////////////////
 404 void printDataBuffer(const size_t byteCount, const uint8_t* pData) {
 405
 406     uint64_t index = 0;
 407     while (index < byteCount) {
 408         if (index > 0 && index % 50 == 0) {
 409             printf("\n");
 410         }
 411         printf("%u ",pData[index]);
 412         index++;
 413     }
 414 }
 415
 416 //////////////////////////////////////////////////////////////////////
 417 void printRICSubscriptionRequest(const RICSubscriptionRequest_t* pRICSubscriptionRequest) {
 418     printf("pRICSubscriptionRequest->ricRequestID.ricRequestorID = %u\n", pRICSubscriptionRequest->ricRequestID.ricRequestorID);
 419     printf("pRICSubscriptionRequest->ricRequestID.ricInstanceID = %u\n", pRICSubscriptionRequest->ricRequestID.ricInstanceID);
 420     printf("pRICSubscriptionRequest->ranFunctionID = %u\n",pRICSubscriptionRequest->ranFunctionID);
 421
 422     printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength = %li\n",
 423          pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 424     printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data = ");
 425     printDataBuffer(pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength,
 426                     pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data);
 427     printf("\n");
 428
 429     printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = %u\n",
 430          (unsigned)pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength);
 431
 432     uint64_t index = 0;
 433     while (index < pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength) {
 434         printf("index = %lu\n", index);
 435         printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID = %li\n",
 436              pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID);
 437         printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType = %li\n",
 438              pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType);
 439         printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = %i\n",
 440              pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent);
 441         if(pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent)
 442         {
 443             printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength = %li\n",
 444                  pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength);
 445             printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data = ");
 446             printDataBuffer(pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength,
 447                             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data);
 448             printf("\n");
 449         }
 450
 451         printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = %i\n",
 452           pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent);
 453         if(pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent)
 454         {
 455             printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType = %li\n",
 456                  pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType);
 457             printf("pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait = %li\n",
 458                  pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait);
 459         }
 460         printf("\n\n");
 461         index++;
 462     }
 463     printf("\n\n");
 464 }
 465
 466 //////////////////////////////////////////////////////////////////////
 467 void printRICSubscriptionResponse(const RICSubscriptionResponse_t* pRICSubscriptionResponse) {
 468
 469     printf("pRICSubscriptionResponse->ricRequestID.ricRequestorID = %u\n",pRICSubscriptionResponse->ricRequestID.ricRequestorID);
 470     printf("pRICSubscriptionResponse->ricRequestID.ricInstanceID = %u\n", pRICSubscriptionResponse->ricRequestID.ricInstanceID);
 471     printf("pRICSubscriptionResponse->ranFunctionID = %u\n",pRICSubscriptionResponse->ranFunctionID);
 472     printf("pRICSubscriptionResponse->ricActionAdmittedList.contentLength = %u\n",(unsigned)pRICSubscriptionResponse->ricActionAdmittedList.contentLength);
 473     uint64_t index = 0;
 474     while (index < pRICSubscriptionResponse->ricActionAdmittedList.contentLength) {
 475         printf("pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index] = %lu\n",pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index]);
 476         index++;
 477     }
 478     printf("pRICSubscriptionResponse->ricActionNotAdmittedListPresent = %u\n",pRICSubscriptionResponse->ricActionNotAdmittedListPresent);
 479     printf("pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = %u\n",(unsigned)pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength);
 480     index = 0;
 481     while (index < pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength) {
 482         printf("pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID = %lu\n",
 483              pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID);
 484         printf("pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = %u\n",
 485              (unsigned)pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content);
 486         printf("pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.cause = %u\n",
 487              (unsigned)pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal);
 488         index++;
 489     }
 490     printf("\n");
 491 }
 492
 493 //////////////////////////////////////////////////////////////////////
 494 void printRICSubscriptionFailure(const RICSubscriptionFailure_t* pRICSubscriptionFailure) {
 495
 496     printf("pRICSubscriptionFailure->ricRequestID.ricRequestorID = %u\n",pRICSubscriptionFailure->ricRequestID.ricRequestorID);
 497     printf("pRICSubscriptionFailure->ricRequestID.ricInstanceID = %u\n",pRICSubscriptionFailure->ricRequestID.ricInstanceID);
 498     printf("pRICSubscriptionFailure->ranFunctionID = %i\n",pRICSubscriptionFailure->ranFunctionID);
 499     printf("pRICSubscriptionFailure->ricActionNotAdmittedList.content = %u\n",pRICSubscriptionFailure->cause.content);
 500     printf("pRICSubscriptionFailure->ricActionNotAdmittedList.content = %u\n",pRICSubscriptionFailure->cause.causeVal);
 501     if (pRICSubscriptionFailure->criticalityDiagnosticsPresent) {
 502         printf("pRICSubscriptionFailure->criticalityDiagnosticsPresent = %u\n",pRICSubscriptionFailure->criticalityDiagnosticsPresent);
 503         printf("pRICSubscriptionFailure->criticalityDiagnostics.procedureCodePresent = %u\n",pRICSubscriptionFailure->criticalityDiagnostics.procedureCodePresent);
 504         printf("pRICSubscriptionFailure->criticalityDiagnostics.procedureCode = %u\n",(unsigned)pRICSubscriptionFailure->criticalityDiagnostics.procedureCode);
 505         printf("pRICSubscriptionFailure->criticalityDiagnostics.triggeringMessagePresent = %u\n",pRICSubscriptionFailure->criticalityDiagnostics.triggeringMessagePresent);
 506         printf("pRICSubscriptionFailure->criticalityDiagnostics.triggeringMessage = %u\n",(unsigned)pRICSubscriptionFailure->criticalityDiagnostics.triggeringMessage);
 507         printf("pRICSubscriptionFailure->criticalityDiagnostics.procedureCriticalityPresent = %u\n",pRICSubscriptionFailure->criticalityDiagnostics.procedureCriticalityPresent);
 508         printf("pRICSubscriptionFailure->criticalityDiagnostics.procedureCriticality = %u\n",(unsigned)pRICSubscriptionFailure->criticalityDiagnostics.procedureCriticality);
 509         printf("pRICSubscriptionFailure->criticalityDiagnostics.iEsCriticalityDiagnosticsPresent = %u\n",pRICSubscriptionFailure->criticalityDiagnostics.iEsCriticalityDiagnosticsPresent);
 510         printf("pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIELength = %u\n",pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIELength);
 511         unsigned int index = 0;
 512         while (index < pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIELength) {
 513             printf("pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIEListItem[index].iECriticality = %u\n",
 514                  (unsigned)pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIEListItem[index].iECriticality);
 515             printf("pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIEListItem[index].iE_ID = %u\n",
 516                  pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIEListItem[index].iE_ID);
 517             printf("pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIEListItem[index].typeOfError = %u\n",
 518                  (unsigned)pRICSubscriptionFailure->criticalityDiagnostics.criticalityDiagnosticsIEListItem[index].typeOfError);
 519             index++;
 520         }
 521     }
 522     printf("\n");
 523 }
 524
 525 void printRICSubscriptionDeleteRequest(const RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
 526
 527     printf("\npRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID = %u\n",pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID);
 528     printf("pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID = %u\n",pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID);
 529     printf("pRICSubscriptionDeleteRequest->ranFunctionID = %i\n",pRICSubscriptionDeleteRequest->ranFunctionID);
 530     printf("\n");
 531 }
 532
 533 void printRICSubscriptionDeleteResponse(const RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
 534
 535     printf("\npRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID = %u\n",pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID);
 536     printf("pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID = %u\n",pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID);
 537     printf("pRICSubscriptionDeleteResponse->ranFunctionID = %i\n",pRICSubscriptionDeleteResponse->ranFunctionID);
 538     printf("\n");
 539 }
 540
 541 void printRICSubscriptionDeleteFailure(const RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
 542
 543     printf("\npRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID = %u\n",pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID);
 544     printf("pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID = %u\n",pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID);
 545     printf("pRICSubscriptionDeleteFailure->ranFunctionID = %i\n",pRICSubscriptionDeleteFailure->ranFunctionID);
 546     printf("pRICSubscriptionDeleteFailure->ricCause.content = %i\n",pRICSubscriptionDeleteFailure->cause.content);
 547     printf("pRICSubscriptionDeleteFailure->ricCause.cause = %i\n",pRICSubscriptionDeleteFailure->cause.causeVal);
 548     printf("\n");
 549 }
 550
 551 #endif