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-csharp.html 3327 2026-01-06 10:07:48Z macra $

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

// Classes generated from the ASN.1 specification.
using Rrc;
using Rrc.NRRRCDefinitions;

// OSS runtime library Classes.
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 that contains encoded messages.
            string dataDir = (args.Length > 0) ? args[0] : "../../";
            Trrc trrc = new Trrc();
            trrc.Process(dataDir, "RRCRelease.uper");
            trrc.Process(dataDir, "SecurityModeCommand.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 a UE-side function that processes 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 5G 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 a 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 add support for each unimplemented CHOICE alternative.
            case DLDCCHMessageType.C1Type.Id.CounterCheckChosen :
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.DlDedicatedMessageSegmentR16Chosen:
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.DlInformationTransferChosen:
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.DlInformationTransferMRDCR16Chosen:
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.LoggedMeasurementConfigurationR16Chosen:
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.MobilityFromNRCommandChosen:
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.RrcReconfigurationChosen :
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.RrcReestablishmentChosen :
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.RrcReleaseChosen :
                Console.WriteLine("Printing the decoded request RRCRelease...");
                ValueNotationFormatter.Print(request, Console.Out);
                return null;
            case DLDCCHMessageType.C1Type.Id.RrcResumeChosen :
                Console.WriteLine("Unimplemented.");
                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.Spare1Chosen:
            case DLDCCHMessageType.C1Type.Id.Spare2Chosen:
            case DLDCCHMessageType.C1Type.Id.Spare3Chosen:
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.UeCapabilityEnquiryChosen :
                Console.WriteLine("Unimplemented.");
                return null;
            case DLDCCHMessageType.C1Type.Id.UeInformationRequestR16Chosen:
                Console.WriteLine("Unimplemented.");
                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.SecurityModeCommand == null)
                throw new Exception("Cannot handle ASN.1 data");
        SecurityAlgorithmConfig config = request.Message.C1.
                         SecurityModeCommand.CriticalExtensions.
                         SecurityModeCommand.SecurityConfigSMC.SecurityAlgorithmConfig;
        switch (config.IntegrityProtAlgorithm) {
            case IntegrityProtAlgorithm.Nia0:
            case IntegrityProtAlgorithm.Nia1:
            case IntegrityProtAlgorithm.Nia2:
            case IntegrityProtAlgorithm.Nia3:
                break;
            default:
                throw new Exception("Unknown integrity protection");
        }
        switch (config.CipheringAlgorithm) {
            case CipheringAlgorithm.Nea0:
            case CipheringAlgorithm.Nea1:
            case CipheringAlgorithm.Nea2:
            case CipheringAlgorithm.Nea3:
                break;
            default:
                throw new Exception("Unknown ciphering");
        }
        SecurityModeComplete securityModeComplete = new SecurityModeComplete();
        securityModeComplete.CriticalExtensions = new SecurityModeComplete.CriticalExtensionsType();
        securityModeComplete.CriticalExtensions.SecurityModeComplete = new SecurityModeCompleteIEs();
        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...");
            ValueNotationFormatter.Print(stream.ToArray(), (int)stream.Length, Console.Out);
        }
    }
}