LTE 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: e3ae625d284b62dac83194f4ed3c7cd6bb6715c8
 */

/*
 * A demonstrative example for handling 3GPP LTE RRC protocol data in ASN.1/C++
 */
#include <errno.h>
#include "rrc.h"

/*
 * Auxiliary function to make output prettier.
 */
void printBorder()
{
    printf("-------------------------------------------------------\n");
}

char *filesDir; /* 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.
		 */


/*
 * A simple class used to report non-ASN.1/C++ errors (such as a failure to
 * create a socket) to the application. You may use any alternative error
 * handling if you wish.
 */

class NonASN1Exception {
private:
    const char *message;	/* can contain C format specifications */
    const char *extra_data;	/* data handled by fmt. specifications (if any) */
    int errcode;
public:
    NonASN1Exception(const char *msg, int code = 0,
	    const char *extd = NULL);
    NonASN1Exception(const NonASN1Exception & that);
    const char *get_message() const;
    const char *get_extra_data() const;
    int get_errcode() const;
};

NonASN1Exception::NonASN1Exception(const char *msg, int code, const char *extd)
{
    message = msg;
    extra_data = extd;
    errcode = code;
}

NonASN1Exception::NonASN1Exception(const NonASN1Exception & that)
{
    message = that.message;
    errcode = that.errcode;
    extra_data = that.extra_data;
}

const char *NonASN1Exception::get_message() const
{
    return message;
}

const char *NonASN1Exception::get_extra_data() const
{
    return extra_data;
}

int NonASN1Exception::get_errcode() const
{
    return errcode;
}

/*
 * FUNCTION     printHexString() prints data (octet string) as a sequence of
 *              hexadecimal digits 'XXXX...'H
 *
 * PARAMETERS
 *    ctl       ASN.1/C++ control object
 *    value     reference to input data (OssString object)
 */
void printHexString(OssControl *ctl, const OssString &value)
{
    ctl->printHex(value.get_buffer(), value.length());
}

/*
 * FUNCTION     printHexBitString() prints data (bit string) as a sequence of
 *              hexadecimal digits 'XXXX...'H
 *
 * PARAMETERS
 *    ctl       ASN.1/C++ control object
 *    value     reference to input data (OssBitString object)
 */
void printHexBitString(OssControl *ctl, const OssBitString &value)
{
    ctl->printHex((const char *)value.get_buffer(), (value.length() + 7) / 8);
}

/*
 * FUNCTION     Helper function to open file in the specified directory.
 *
 * PARAMETERS
 *     directoryName    directory where fileName resides
 *     fileName         file to open
 *
 * RETURNS      pointer to file on success, NULL on failure
 */
FILE * openInputFile(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 = (char *)asn1Malloc(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"))) {
	printf("Failed to open the '%s' file. Restart the sample program using the file "
		"location as the input parameter.\n", path);
    }

    if (path != fileName)
	asn1Free(path);

    return fv;
}

/*
 * FUNCTION     readEncodingFromFile() reads serialized message from specified
 *              file
 *
 * PARAMETERS
 *    filename  name of file containing serialized message
 *
 * RETURNS      a pointer to a newly allocated EncodedBuffer object containing
 *              the encoding read from the file
 */
static EncodedBuffer *readEncodingFromFile(const char *filename)
{
    long length;
    FILE *in = NULL;
    unsigned char *data = NULL;
    EncodedBuffer *result = new EncodedBuffer();

    try {
	/* Open the file and determine its length */
	in = openInputFile(filesDir, filename);
	if (!in)
	    throw NonASN1Exception(strerror(errno), errno);
	if (fseek(in, 0, SEEK_END))
	    throw NonASN1Exception(strerror(errno), errno);
	length = ftell(in);
	if (length < 0)
	    throw NonASN1Exception(strerror(errno), errno);

	/*
	 * Allocate memory. We need to use asn1Malloc so we can later pass
	 * the ownership of the allocated memory to the EncodedBuffer object.
	 */
	data = (unsigned char *)asn1Malloc(length);
	if (!data)
	    throw NonASN1Exception("No memory", OUT_MEMORY);

	/* Read the file */
	rewind(in);
	if (length != (long)fread(data, 1, (size_t)length, in))
	    throw NonASN1Exception("Error reading the file", 0);
	fclose(in);

	/* Pass the read buffer to the EncodedBuffer */
	result->grab_buffer(length, (char *)data);
	return result;
    } catch (...) {
	if (in)
	    fclose(in);
	if (data)
	    asn1Free(data);
	delete result;
	throw;
    }
}

/*
 * FUNCTION     createSecurityModeCommandResponse() creates an RRC successful
 *              outcome message for a given SecurityModeCommand request.
 *
 * PARAMETERS
 *    ctl       OSS control object
 *    sec_mode  input message (request)
 *    response  pointer to the variable that is to hold the resulting
 *              successful outcome message created by the function
 */
void createSecurityModeCommandResponse(OssControl *ctl,
	SecurityModeCommand *sec_mode, UL_DCCH_Message **resp)
{
    SecurityModeCommand::criticalExtensions & crit_ext =
	    sec_mode->get_criticalExtensions();
    SecurityModeCommand::criticalExtensions::c1 *crit_ext_c1;
    SecurityModeCommand_r8_IEs *ies;
    SecurityAlgorithmConfig::integrityProtAlgorithm ipalg;
    SecurityAlgorithmConfig::cipheringAlgorithm calg;
    UL_DCCH_Message *response;

    if (!(crit_ext_c1 = crit_ext.get_c1()))
	throw NonASN1Exception("Unsupported SecurityModeCommand", -1, NULL);
    if (!(ies = crit_ext_c1->get_securityModeCommand_r8()))
	throw NonASN1Exception("Unsupported SecurityModeCommand", -1, NULL);

    /* Getting integrity protection algorithm and ciphering algorithm */
    SecurityAlgorithmConfig & sec_conf =
	    ies->get_securityConfigSMC().get_securityAlgorithmConfig();
    ipalg = sec_conf.get_integrityProtAlgorithm();
    calg = sec_conf.get_cipheringAlgorithm();

    /* Checking validity of the values */
    if (ipalg != eia0_v920 && ipalg != eia1 && ipalg != eia2)
	throw NonASN1Exception("Unknown integrity protection", -1, NULL);
    if (calg != eea0 && calg != eea1 && calg != eea2)
	throw NonASN1Exception("Unknown ciphering", -1, NULL);

    try {
	/* Allocate response message */
	response = new UL_DCCH_Message();

	UL_DCCH_MessageType content;
	UL_DCCH_MessageType::c1 inner_content;
	SecurityModeComplete sec_mode_comp;

	/* Copy transaction identifier from the request */
	sec_mode_comp.set_rrc_TransactionIdentifier(
		sec_mode->get_rrc_TransactionIdentifier());

	/*
	 * SecurityModeComplete_r8_IEs has no mandatory components. Here
	 * we are creating an empty SecurityModeComplete_r8_IEs object.
	 */
	sec_mode_comp.get_criticalExtensions().set_securityModeComplete_r8(
		SecurityModeComplete_r8_IEs());

	/* Construct a response message */
	inner_content.set_securityModeComplete(sec_mode_comp);
	content.set_c1(inner_content);
	response->set_message(content);
	*resp = response;
    } catch (...) {
	/* In case of any error, delete the response object */
	delete response;
    }
}

/*
 * FUNCTION     testDL_DCCH_Message() is used to test an RRC message received
 *		by the downlink DCCH channel. The input serialized
 *              pdu is deserialized and printed, then an outcome message
 *              is created, printed and encoded. This version processes
 *              only securityModeCommand messages and rrcConnectionRelease
 *              messages (only partially, just printing the input message).
 *              However, it can be easily extended to other message types.
 *
 * PARAMETERS
 *    ctl       OSS control object
 *    filename  name of file containing serialized message
 */
static void testDL_DCCH_Message(OssControl *ctl, const char *filename)
{
    EncodedBuffer *encoded_request;
    EncodedBuffer encoded_response;
    DL_DCCH_Message_PDU req_pdu;
    UL_DCCH_Message_PDU resp_pdu;
    DL_DCCH_Message *request;
    UL_DCCH_Message *response;

    printf("======================================================"
	    "======================\n");
    printf("Read encoding from file: %s\n\n", filename);
    /* Read serialized message from file */
    encoded_request = readEncodingFromFile(filename);
    try {
	DL_DCCH_MessageType::c1 *content;
	RRCConnectionRelease *conn_rel;
	SecurityModeCommand *sec_mode;
	LoggedMeasurementConfiguration_r10 *meas_conf;

	printf("Decoding the input downlink DCCH message\n");
	printBorder();

	/* Decode the input message */
	req_pdu.decode(*ctl, *encoded_request);

	/* Free memory allocated for encoded message */
	delete encoded_request;
	encoded_request = NULL;

	request = req_pdu.get_data();
	content = request->get_message().get_c1();
	if (!content)
	    throw NonASN1Exception("Incorrect message", -1, NULL);

	printf("PDU decoded\n");
	printBorder();

	/* Depending on the message type... */
	if ((conn_rel = content->get_rrcConnectionRelease())) {
	    /* rrcConnectionRelease */

	    /* Print deserialized message */
	    req_pdu.print(*ctl);
	} else if ((sec_mode = content->get_securityModeCommand())) {
	    /* securityModeCommand */

	    /* Print deserialized message */
	    req_pdu.print(*ctl);
	    printf("Creating response\n");
	    printBorder();

	    /* Create response */
	    createSecurityModeCommandResponse(ctl, sec_mode, &response);
	    printf("\nResponse created successfully\n");

	    /* Print the response message */
	    resp_pdu.set_data(*response);
	    resp_pdu.print(*ctl);

	    /* Serialize response */
	    printf("\nEncoding response\n");
	    printBorder();
	    resp_pdu.encode(*ctl, encoded_response);
	    printf("Encoded response (%lu bytes):\n",
		    encoded_response.get_length());
	    printBorder();
	    encoded_response.print_hex(*ctl);
	    printf("\n");

	    /* Free memory allocated for outcome message */
	    delete response;
	} else if ((meas_conf = content->get_loggedMeasurementConfiguration_r10())) {
	    /* LoggedMeasurementConfiguration_r10 */

	    /* Print deserialized message */
	    req_pdu.print(*ctl);
	} else {
	    /* Other message types */

	    printf("Unimplemented\n");
	}

	/* Free the decoded input message */
	req_pdu.free_data(*ctl);
    } catch (...) {
	/* Cleanup in case of any error */
	delete encoded_request;
	throw;
    }
}
/*
 * Main application routine
 */
int main(int argc, char *argv[])
{
    int retcode;
    filesDir = argc > 1 ? argv[1] : (char *) ".";

    try {
	rrc_Control ctl;

	/* Set the encoding rules and encoding/decoding flags */
	ctl.setEncodingRules(OSS_PER_UNALIGNED);
	ctl.setEncodingFlags(AUTOMATIC_ENCDEC | STRICT_PER_ENCODING_OF_DEFAULT_VALUES);
	ctl.setDecodingFlags(AUTOMATIC_ENCDEC);
	ctl.setDebugFlags(PRINT_ERROR_MESSAGES | PRINT_DECODING_DETAILS |
		PRINT_ENCODING_DETAILS);

	testDL_DCCH_Message(&ctl, "RRCConnectionRelease.uper");
	testDL_DCCH_Message(&ctl, "SecurityModeCommand.uper");
	testDL_DCCH_Message(&ctl, "LoggedMeasurementConfiguration.uper");
	retcode = 0;
    } catch (ASN1RuntimeException &exc) {
        retcode = exc.get_code();
	printf("An error occurred: code = %d.\n", retcode);
    } catch (NonASN1Exception &exc) {
	printf("NonASN1Exception: ");
	retcode = exc.get_errcode();
	printf(exc.get_message(), exc.get_extra_data(), retcode);
        printf("\n");
        if (!retcode)
	    retcode = -1;
    } catch (...) {
	printf("An unexpected exception occurred.\n");
	retcode =  -1;
    }
    if (!retcode)
	printf("\nTesting successful.\n");

    return retcode;
}