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

//
// Demonstrates part of RRC protocol layer of an LTE UE stack.
//

// Classes generated from ASN.1 specification.
using Rrc;
using Rrc.EUTRARRCDefinitions;

// Classes from the OSS runtime library.
using Oss.Asn1;

// C# system classes.
using System;
using System.Collections.Generic;
using System.IO;


public class Program
{
    public static int Main(string[] args)
    {
	try
	{
	    // A folder with encoded messages.
	    string dataDir = (args.Length > 0) ? args[0] : "../../";
	    Trrc trrc = new Trrc();
	    trrc.Process(dataDir, "ConnectionRelease.uper");
	    trrc.Process(dataDir, "SecurityModeCommand.uper");
	    trrc.Process(dataDir, "LoggedMeasurementConfiguration.uper");
	    Console.WriteLine("Message processing has completed successfully.");
	}
	catch (Exception e)
	{
	    // Print complete exception information.
	    Console.WriteLine(e);
	    return 1;
	}
	return 0;
    }
}

/// <summary>
/// This 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 class can be used to implement a complete LTE RRC UE-side dispatcher.
/// </summary>
public class Trrc
{
    PerUnalignedCodec codec = new PerUnalignedCodec();

    /// <summary>
    /// Processes an input file.
    /// Decodes and prints the input messages.
    /// Creates, encodes and prints the output (response) messages.
    /// </summary>
    public void Process(String dataDir, String fileName)
    {
	try
	{
	    String fullPath = Path.Combine(dataDir, fileName);
	    DLDCCHMessage request = GetRequest(fullPath);
	    ULDCCHMessage response = GetResponse(request);
	    if (response != null)
		Send(response);
	    Console.WriteLine();
	}
	catch (Exception e)
	{
	    throw new Exception("Processing error for file: " + fileName, e);
	}
    }

    /// <summary>
    /// This methods decodes a DLDCCHMessage PDU from a file.
    /// </summary>
    DLDCCHMessage GetRequest(String fileName)
    {
	using (Stream stream = File.OpenRead(fileName))
	{
	    Console.WriteLine("Decoding the DLDCCHMessage PDU from the file " + fileName + "...");
	    DLDCCHMessage request = new DLDCCHMessage();
	    codec.Decode(stream, request);
	    Console.WriteLine("PDU decoded successfully.");
	    return request;
	}
    }

    /// <summary>
    /// This method creates an UL_DCCH_Message PDU for a given DL_DCCH_Message PDU
    /// </summary>
    ULDCCHMessage GetResponse(DLDCCHMessage request)
    {
	// Checking message.
	// The selected CHOICE alternative can be found by comparing the fields with null.
	if (request.Message.C1 == null)
	    throw new Exception("Invalid message.");
	// The selected CHOICE alternative can be found
	// by comparing the Selected field with the corresponding enum items.
	switch (request.Message.C1.Selected) {
	    // You can take unimplemented CHOICE alternatives one by one and add support for them
	    case DLDCCHMessageType.C1Type.Id.CsfbParametersResponseCDMA2000Chosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.DlInformationTransferChosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.HandoverFromEUTRAPreparationRequestChosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.MobilityFromEUTRACommandChosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.RrcConnectionReconfigurationChosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.RrcConnectionReleaseChosen :
		Console.WriteLine("Printing the decoded request RRCConnectionRelease...");
		ValueNotationFormatter.Print(request, Console.Out);
		return null;
	    case DLDCCHMessageType.C1Type.Id.SecurityModeCommandChosen :
		Console.WriteLine("Printing the decoded request SecurityModeCommand...");
		ValueNotationFormatter.Print(request, Console.Out);
		return CreateSecurityModeCommandResponse(request);
	    case DLDCCHMessageType.C1Type.Id.UeCapabilityEnquiryChosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.CounterCheckChosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.UeInformationRequestR9Chosen :
		Console.WriteLine("Unimplemented.");
		return null;
	    case DLDCCHMessageType.C1Type.Id.LoggedMeasurementConfigurationR10Chosen :
		Console.WriteLine("Printing the decoded request LoggedMeasurementConfigurationR10...");
		ValueNotationFormatter.Print(request, Console.Out);
		return null;
	    case DLDCCHMessageType.C1Type.Id.RnReconfigurationR10Chosen :
		Console.WriteLine("The message is not intended for UE");
		return null;
	    default:
		Console.WriteLine("Unknown CHOICE alternative selected.");
		return null;
	}
    }

    /// <summary>
    /// This method creates a "security mode complete" ULDCCHMessage PDU
    /// for the given "security mode command" DL_DCCH_Message PDU.
    /// </summary>
    ULDCCHMessage CreateSecurityModeCommandResponse(DLDCCHMessage request)
    {
	Console.WriteLine("\nCreating the ULDCCHMessage response message...");
	// Check if request is valid.
	if (request.Message.C1 == null ||
	    request.Message.C1.SecurityModeCommand == null ||
	    request.Message.C1.SecurityModeCommand.CriticalExtensions.C1 == null ||
	    request.Message.C1.SecurityModeCommand.CriticalExtensions.C1.SecurityModeCommandR8 == null)
	    throw new Exception("Cannot handle ASN.1 data");
	SecurityAlgorithmConfig config = request.Message.C1.
					 SecurityModeCommand.CriticalExtensions.C1.
					 SecurityModeCommandR8.SecurityConfigSMC.SecurityAlgorithmConfig;
	switch (config.IntegrityProtAlgorithm) {
	    case SecurityAlgorithmConfig.IntegrityProtAlgorithmType.Eia0V920:
	    case SecurityAlgorithmConfig.IntegrityProtAlgorithmType.Eia1:
	    case SecurityAlgorithmConfig.IntegrityProtAlgorithmType.Eia2:
            case SecurityAlgorithmConfig.IntegrityProtAlgorithmType.Eia3V1130:
		break;
	    default:
		throw new Exception("Unknown integrity protection");
	}
	switch (config.CipheringAlgorithm) {
	    case CipheringAlgorithmR12.Eea0:
            case CipheringAlgorithmR12.Eea1:
            case CipheringAlgorithmR12.Eea2:
            case CipheringAlgorithmR12.Eea3V1130:
                break;
	    default:
		throw new Exception("Unknown ciphering");
	}
	SecurityModeComplete securityModeComplete = new SecurityModeComplete();
	securityModeComplete.CriticalExtensions = new SecurityModeComplete.CriticalExtensionsType();
	securityModeComplete.CriticalExtensions.SecurityModeCompleteR8 = new SecurityModeCompleteR8IEs();
	securityModeComplete.RrcTransactionIdentifier = request.Message.C1.SecurityModeCommand.RrcTransactionIdentifier;

	ULDCCHMessage response = new ULDCCHMessage();
	response.Message = new ULDCCHMessageType();
	response.Message.C1 = new ULDCCHMessageType.C1Type();
	response.Message.C1.SecurityModeComplete = securityModeComplete;
	Console.WriteLine("Response created successfully.");
	Console.WriteLine("\nPrinting the created response...");
	ValueNotationFormatter.Print(response, Console.Out);
	return response;
    }

    /// <summary>
    /// Encodes and sends a ULDCCHMessage message.
    /// </summary>
    void Send(ULDCCHMessage message)
    {
	using (MemoryStream stream = new MemoryStream())
	{
	    Console.WriteLine("Encoding the response...");
	    codec.Encode(message, stream);
	    Console.WriteLine("Encoded successfully.\n");
	    // Print the encoded outcome message.
	    Console.WriteLine("Printing the response PDU in " + stream.Length + " bytes...");
	    Console.WriteLine(BitConverter.ToString(stream.ToArray()));
	}
    }
}