5G RRC C Sample Code Using OSS ASN.1 Tools

/*****************************************************************************/
/*  Copyright (C) 2025 OSS Nokalva, Inc.  All rights reserved.               */
/*****************************************************************************/
/* THIS FILE IS PROPRIETARY MATERIAL OF OSS NOKALVA, INC.                    */
/* AND MAY BE USED ONLY BY DIRECT LICENSEES OF OSS NOKALVA, INC.             */
/* THIS FILE MAY NOT BE DISTRIBUTED.                                         */
/* THIS COPYRIGHT STATEMENT MAY NOT BE REMOVED.                              */
/* THIS SAMPLE PROGRAM IS PROVIDED AS IS. THE SAMPLE PROGRAM AND ANY RESULTS */
/* OBTAINED FROM IT ARE PROVIDED WITHOUT ANY WARRANTIES OR REPRESENTATIONS,  */
/* EXPRESS, IMPLIED OR STATUTORY.                                            */
/*****************************************************************************/
/*
 * $Id: 5G-rrc-c.html 3327 2026-01-06 10:07:48Z macra $
 */

/*
 * Demonstrates part of RRC protocol layer of a 5G UE stack.
 */

#include <errno.h>
#include <string.h>
#include "rrc_r19.h"

#define printBorder() \
    ossPrint(world, "-------------------------------------------------------\n")

/* The directory where input files reside. It is set to the command line parameter
 * if any and to the directory where the sample is started, otherwise.
 */
char *filesDir;

/*
 * FUNCTION     reportError() prints error message and error code returned
 *              by any runtime API function.
 *
 * PARAMETERS
 *     world    OSS environment variable
 *     where    error origin
 *     errcode  error code
 *     errmsg   error message or NULL if ossGetErrMsg() should be used
 *	        to get it
 *
 * RETURNS      errcode
 */
static int reportError(OssGlobal *world, const char *where,
				    int errcode, const char *errmsg)
{
    /* Error occured */
    if (errcode) {
        ossPrint(world, "%s failed, error code: %d\n", where, errcode);
	/* Get and print error message */
	if (errmsg || (world && NULL != (errmsg = ossGetErrMsg(world))))
	    ossPrint(world, "Error text: %s\n", errmsg);
    }

    return errcode;
}

/*
 * FUNCTION     Helper function to open file in the specified directory.
 *
 * PARAMETERS
 *     world            OSS environment variable
 *     directoryName    directory where fileName resides
 *     fileName         file to open
 *
 * RETURNS      pointer to file on success, NULL on failure
 */
FILE * openInputFile(OssGlobal *world, char *directoryName, const char *fileName)
{
    char *path;
    FILE *fv;
    const char kPathSeparator =
#ifdef _WIN32
				'\\';
#else
				'/';
#endif

    if (directoryName) {
	size_t dLength = strlen(directoryName);

	if (NULL == (path = ossGetMemory(world, dLength + strlen(fileName) + 2))) {
	    return NULL;
	}

	memcpy(path, directoryName, dLength);
	if (path[dLength - 1] != kPathSeparator)
	    path[dLength++] = kPathSeparator;
	strcpy(path+dLength, fileName);
    } else {
	path = (char *) fileName;
    }

    if (!(fv = fopen(path, "rb"))) {
	ossPrint(world, "Failed to open the '%s' file. Restart the sample program using the file "
		"location as the input parameter.\n", path);
    }

    if (path != fileName)
	ossFreeMemory(world, path);

    return fv;
}

/*
 * FUNCTION     readEncodingFromFile() reads serialized message from specified
 *              file
 *
 * PARAMETERS
 *    world     OSS environment variable
 *    filename  name of file containing serialized message
 *    encoding  read message
 *
 * RETURNS      0 on success, error code on failure
 */
static int readEncodingFromFile(OssGlobal *world,
				    const char *filename, OssBuf *encoding)
{
    FILE        *in = openInputFile(world, filesDir, filename);
    long        length;
    unsigned char *data;

    if (!in)
	return reportError(world, "fopen()", errno, strerror(errno));

    if (fseek(in, 0, SEEK_END))
	return reportError(world, "fseek()", errno, strerror(errno));

    length = ftell(in);
    if (length < 0)
	return reportError(world, "ftell()", errno, strerror(errno));

    /* Allocate memory to store completely read message in it */
    data = ossGetMemory(world, (size_t)length);
    if (!data) {
	reportError(world, "ossGetMemory()", OUT_MEMORY, NULL);
	fclose(in);
	return OUT_MEMORY;
    }
    rewind(in);

    if ((size_t)length != fread(data, sizeof(char), (size_t)length, in))
	return reportError(world, "fread()", 1, NULL);
    fclose(in);

    /* Store read message in output argument */
    encoding->value = data;
    encoding->length = (size_t)length;

    return 0;
}

/*
 * FUNCTION     createSecurityModeCommandResponse() creates an
 *              OSS_RRC_UL_DCCH_Message PDU (security mode complete) for given
 *              OSS_RRC_DL_DCCH_Message PDU (security mode command).
 *
 * PARAMETERS
 *    world     OSS environment variable
 *    req       input message
 *    resp      pointer to the response created by the function
 *
 * RETURNS      0 on success, error code on failure
 */
static int createSecurityModeCommandResponse(OssGlobal *world,
					     OSS_RRC_DL_DCCH_Message *req,
					     OSS_RRC_UL_DCCH_Message **resp)
{
    OSS_RRC_SecurityAlgorithmConfig_integrityProtAlgorithm ipalg;
    OSS_RRC_CipheringAlgorithm calg;

    if (req->message.choice != OSS_RRC_DL_DCCH_MessageType_c1_chosen
            || req->message.u.c1.choice != OSS_RRC_securityModeCommand_chosen
            || req->message.u.c1.u.securityModeCommand.criticalExtensions.choice
            != OSS_RRC_SecurityModeCommand_criticalExtensions_c1_chosen) {
	ossPrint(world, "cannot handle ASN.1 data\n");
	return -1;
    }

    ipalg =
	req->message.u.c1.u.securityModeCommand.criticalExtensions.u.securityModeCommand.securityConfigSMC.securityAlgorithmConfig.integrityProtAlgorithm;
    calg =
	req->message.u.c1.u.securityModeCommand.criticalExtensions.u.securityModeCommand.securityConfigSMC.securityAlgorithmConfig.cipheringAlgorithm;

    if (ipalg != OSS_RRC_integrityProtAlgorithm_reserved
            && ipalg != OSS_RRC_integrityProtAlgorithm_nia1
            && ipalg != OSS_RRC_integrityProtAlgorithm_nia2) {
	ossPrint(world, "unknown integrity protection\n");
	return -1;
    }

    if (calg != OSS_RRC_nea0
            && calg != OSS_RRC_nea1
            && calg != OSS_RRC_nea2) {
	ossPrint(world, "unknown ciphering\n");
	return -1;
    }

    *resp = ossGetInitializedMemory(world, sizeof(OSS_RRC_UL_DCCH_Message));
    if (!*resp)
	return reportError(world, "ossGetInitializedMemory for OSS_RRC_UL_DCCH_Message", OUT_MEMORY, NULL);

    (*resp)->message.choice = OSS_RRC_UL_DCCH_MessageType_c1_chosen;
    (*resp)->message.u.c1.choice = OSS_RRC_c1_securityModeComplete_chosen;
    (*resp)->message.u.c1.u.securityModeComplete.rrc_TransactionIdentifier =
			req->message.u.c1.u.securityModeCommand.rrc_TransactionIdentifier;
    (*resp)->message.u.c1.u.securityModeComplete.criticalExtensions.choice =
	        	OSS_RRC_securityModeComplete_chosen;

    return 0;
}

/*
 * FUNCTION     testDL_DCCH_Message() represents an incomplete implementation
 *              of UE-side function processing a downlink DCCH message. It
 *              decodes the message, prints it, and creates a response for some
 *              particular alternatives. The function can be used to implement
 *              a complete 5G RRC UE-side dispatcher.
 *
 * PARAMETERS
 *    world	OSS environment variable
 *    filename  name of the file containing the input message
 *
 * RETURNS      0 on success, error code on failure
 */
static int testDL_DCCH_Message(OssGlobal *world, const char *filename)
{
    OssBuf	encoded_data;
    int		err, pdu_num = OSS_RRC_DL_DCCH_Message_PDU;

    ossPrint(world, "======================================================"
		"======================\n");
    ossPrint(world, "Read encoding from file: %s\n\n", filename);
    /* Read serialized message from file */
    err = readEncodingFromFile(world, filename, &encoded_data);
    if (!err) {
	/*
	 * Zero deserialized message pointer in order to allocate it
	 * in API call
	 */
	OSS_RRC_DL_DCCH_Message    *req = NULL;
	OSS_RRC_UL_DCCH_Message    *resp = NULL;
	OSS_RRC_DL_DCCH_MessageType_c1 *msg_typ;

	ossPrint(world, "Decoding the input downlink DCCH message\n");
	printBorder();
	/* Deserialize input message */
	err = ossDecode(world, &pdu_num, &encoded_data, (void**)&req);
        ossPrint(world, "\n");
	/* Print error diagnostics if an error takes place */
	if (err) {
	    reportError(world, "ossDecode()", err, NULL);
	} else {
	    if (req->message.choice != OSS_RRC_DL_DCCH_MessageType_c1_chosen) {
		ossPrint(world, "Incorrect message\n");
	    } else {
		msg_typ = &req->message.u.c1;

		ossPrint(world, "PDU decoded\n");
		printBorder();
                switch (msg_typ->choice) {
		    /* You can take unimplemented CHOICE alternatives one by
		     * one and add support for them */
		    case OSS_RRC_rrcReconfiguration_chosen:
			ossPrint(world, "Unimplemented \n");
			break;
		    case OSS_RRC_rrcRelease_chosen:
			/* Print deserialized message */
			err = ossPrintPDU(world, OSS_RRC_DL_DCCH_Message_PDU, req);
			if (err)
			    reportError(world, "ossPrintPDU()", err, NULL);
			break;
		    case OSS_RRC_securityModeCommand_chosen:
			/* Print deserialized message */
			err = ossPrintPDU(world, OSS_RRC_DL_DCCH_Message_PDU, req);
			if (err) {
			    reportError(world, "ossPrintPDU()", err, NULL);
			} else {
		    	    ossPrint(world, "\n");
		    	    ossPrint(world, "Creating response\n");
		    	    printBorder();
			    /* Create response */
			    err = createSecurityModeCommandResponse(world, req, &resp);
			    if (err) {
			        reportError(world, "createSecurityModeCommandResponse()", err, NULL);
			    } else {
		    		OssBuf     msg = { 0, NULL };

		    	        ossPrint(world, "\n");
		    	        ossPrint(world, "Response created successfully\n");
		    	        printBorder();
		    		/* Print outcome message */
		    		err = ossPrintPDU(world, OSS_RRC_UL_DCCH_Message_PDU, resp);
		    		ossPrint(world, "\n");
		    		ossPrint(world, "Encoding response\n");
		    		printBorder();
		    		/* Serialize outcome message */
		    		err = ossEncode(world, OSS_RRC_UL_DCCH_Message_PDU, resp, &msg);
		    		ossPrint(world, "\n");
		    		if (err) {
				    reportError(world, "ossEncode()", err, NULL);
		    		/* Print serialized outcome message */
		    		} else {
				    ossPrint(world, "Encoded response (%ld bytes):\n",
				    					msg.length);
				    printBorder();
				    ossPrintHex(world, (char *)msg.value, msg.length);
				    ossFreeBuf(world, msg.value);
				    ossPrint(world, "\n\n");
		    	        }
		    	        /* Free memory allocated for outcome message */
		                ossFreePDU(world, OSS_RRC_UL_DCCH_Message_PDU, resp);
                            }
			}
			break;
		    case OSS_RRC_dlInformationTransfer_chosen:
			ossPrint(world, "Unimplemented \n");
			break;
		    case OSS_RRC_ueCapabilityEnquiry_chosen:
			ossPrint(world, "Unimplemented \n");
			break;
		    case OSS_RRC_counterCheck_chosen:
			ossPrint(world, "Unimplemented \n");
			break;
		    case OSS_RRC_mobilityFromNRCommand_chosen:
			ossPrint(world, "Unimplemented \n");
			break;
		    default:
			ossPrint(world, "Unknown CHOICE alternative selected\n");
			break;
		}
	    }
	}
	if (req)
	    ossFreePDU(world, OSS_RRC_DL_DCCH_Message_PDU, req);
	/* Free memory allocated for reading of input message from file */
	ossFreeBuf(world, encoded_data.value);
    }
    return err;
}

/*
 * Decodes and prints the input messages; creates, encodes and prints
 * the output (response) messages.
 */
int main(int argc, char *argv[])
{
    OssGlobal world_data, *world = &world_data;
    int err = 0;

    err = ossinit(world, rrc);
    if (err)
	return reportError(NULL, "ossinit()", err, NULL);

    filesDir = argc > 1 ? argv[1] : ".";

    /* Set flags */
    ossSetFlags(world, AUTOMATIC_ENCDEC | STRICT_PER_ENCODING_OF_DEFAULT_VALUES);
    /* Set debug mode */
    ossSetDebugFlags(world, PRINT_ERROR_MESSAGES | PRINT_DECODING_DETAILS | PRINT_ENCODING_DETAILS);

    err = testDL_DCCH_Message(world, "RRCRelease.uper");

    if (!err)
	err = testDL_DCCH_Message(world, "SecurityModeCommand.uper");

    /* Free all resources */
    ossterm(world);

    if (!err)
	printf("Testing successful.\n");

    return err;
}