5G NGAP 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-ngap-csharp.html 3363 2026-02-16 09:51:05Z macra $

//
// Demonstrates part of the 5G NGAP protocol.
//


// Classes generated from ASN.1 specification.
using Ngap;
using Ngap.NGAPPDUDescriptions;
using Ngap.NGAPPDUContents;
using Ngap.NGAPContainers;
using Ngap.NGAPIEs;
using NGAPConstants = Ngap.NGAPConstants.Values;

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

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


public class Program
{
    public static int Main(string[] args)
    {
        try
        {
            // A folder with encoded messages.
            string dataDir = (args.Length > 0) ? args[0] : "../../";
            Tngap tngap = new Tngap();
            tngap.Process(dataDir, "NGAP-PDU_HandoverRequest.per");
            Console.WriteLine("Message processing has completed successfully.");
            return 0;
        }
        catch (Exception e)
        {
            // Print complete exception information.
            Console.WriteLine("ERROR: Error processing input files.");
            Console.WriteLine(e);
            return 1;
        }
    }
}

/// <summary>
/// Does all the processing of the files with encoded PDUs.
/// </summary>
public class Tngap
{
    PerAlignedCodec codec = new PerAlignedCodec();
    /// <summary>
    /// Processes a file with encoded NGAP PDU.
    /// </summary>
    public void Process(String dataDir, String fileName)
    {
        try
        {
            String fullPath = Path.Combine(dataDir, fileName);
            NGAPPDU req = DecodeRequest(fullPath);
            Console.WriteLine("\nPrinting the PER-Decoded NGAPPDU PDU...\n");
            ValueNotationFormatter.Print(req, Console.Out);
            NGAPPDU res = CreateResponse(req);
            if (res != null) {
                Console.WriteLine("\nPrinting the created NGAPPDU response PDU...\n");
                ValueNotationFormatter.Print(res, Console.Out);
                EncodeAndSend(res);
            }
            Console.WriteLine();
        }
        catch (Exception e)
        {
            throw new Exception("Unable to process file '" + fileName + "'.", e);
        }
    }

    /// <summary>
    /// Creates NGAPPDU response PDUs.
    /// </summary>
    NGAPPDU CreateResponse(NGAPPDU request)
    {
        // Check that the message contains InitiatingMessage.
        if (request.Selected != NGAPPDU.Id.InitiatingMessageChosen)
            throw new Exception("ERROR: Wrong message.  Expecting InitiatingMessage.");

        InitiatingMessage msg = request.InitiatingMessage;
        ProcedureCode code = ProcedureCodes.ContainsKey(msg.ProcedureCode) ? ProcedureCodes[msg.ProcedureCode] : ProcedureCode.Unknown;

        switch (code) {
            case ProcedureCode.HandoverRequired:
                {
                    HandoverRequired req = (HandoverRequired)msg.Value.Decoded;
                    AccessHandoverRequiredIEs(req);
                    return CreateHandoverCommand(req);
                }
            case ProcedureCode.Unknown:
                Console.WriteLine("WARNING: Got unknown ProcedureCode: " + msg.ProcedureCode);
                return null;
            default:
                Console.WriteLine("WARNING: ProcedureCode " + code + " not implemented yet.");
                return null;
        }
    }

    /// <summary>
    /// Creates a HandoverCommand PDU.
    /// </summary>
    public NGAPPDU CreateHandoverCommand(HandoverRequired req)
    {
        Console.WriteLine("\nCreating a HandoverCommand NGAPPDU PDU message...");
        HandoverRequired.ProtocolIEsType request_IEs = req.ProtocolIEs;

        if (request_IEs == null || request_IEs.Count == 0)
        {
            Console.WriteLine("No IEs in the HandoverRequired message.");
            return null;
        }
        HandoverCommand.ProtocolIEsType response_IEs = new HandoverCommand.ProtocolIEsType();
        // Copy some IEs from the request
        foreach (HandoverRequired.ProtocolIEsType.Element ie in request_IEs)
        {
            if (ie.Id == NGAPConstants.IdAMFUENGAPID) {
                response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
                {
                    Id = NGAPConstants.IdAMFUENGAPID,
                    Criticality = Ngap.NGAPCommonDataTypes.Criticality.Reject,
                    Value = (OpenType)ie.Value.Copy()
                });
            } else if (ie.Id == NGAPConstants.IdRANUENGAPID) {
                response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
                {
                    Id = NGAPConstants.IdRANUENGAPID,
                    Criticality = Ngap.NGAPCommonDataTypes.Criticality.Reject,
                    Value = (OpenType)ie.Value.Copy()
                });
            } else if (ie.Id == NGAPConstants.IdHandoverType) {
                response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
                {
                    Id = NGAPConstants.IdHandoverType,
                    Criticality = Ngap.NGAPCommonDataTypes.Criticality.Reject,
                    Value = (OpenType)ie.Value.Copy()
                });
            } else if (ie.Id == NGAPConstants.IdSourceToTargetTransparentContainer) {
                SourceToTargetTransparentContainer source = (SourceToTargetTransparentContainer)ie.Value.Decoded;
                response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
                {
                    Id = NGAPConstants.IdTargetToSourceTransparentContainer,
                    Criticality = Ngap.NGAPCommonDataTypes.Criticality.Reject,
                    Value = new OpenType(
                        new TargetToSourceTransparentContainer() {
                            Value = source.Value
                        }
                    )
                });
            }
        }
        HandoverCommand handoverCommand = new HandoverCommand()
        {
            ProtocolIEs = response_IEs
        };
        SuccessfulOutcome successfulOutcome = new SuccessfulOutcome()
        {
            ProcedureCode = NGAPConstants.IdHandoverPreparation,
            Criticality = Ngap.NGAPCommonDataTypes.Criticality.Reject,
            Value = new OpenType(handoverCommand)
        };
        NGAPPDU pdu = new NGAPPDU();
        pdu.SuccessfulOutcome = successfulOutcome;
        Console.WriteLine("Created the NGAPPDU response PDU successfully.\n");
        return pdu;
    }

    /// <summary>
    /// Decodes an NGAPPDU request PDU from a file.
    /// </summary>
    NGAPPDU DecodeRequest(String fileName)
    {
        using (Stream stream = File.OpenRead(fileName))
        {
            /// <summary>
            ///  Set the decoder to autodecode open type values.
            /// </summary>
            codec.DecoderOptions.AutoDecode = true;
            Console.WriteLine("\nDecoding the NGAPPDU request PDU from the file " + fileName + "...");
            NGAPPDU msg = new NGAPPDU();
            codec.Decode(stream, msg);
            Console.WriteLine("PDU decoded successfully.");
            return msg;
        }
    }

    /// <summary>
    /// Enumerates possible procedure codes.
    /// </summary>
    public enum ProcedureCode {
        HandoverRequired,
        Unknown
    }

    static Dictionary<int, ProcedureCode> ProcedureCodes = new Dictionary<int, ProcedureCode>() {
        {NGAPConstants.IdHandoverPreparation, ProcedureCode.HandoverRequired}
    };

    private const string PLACEHOLDER = "...";

    /// <summary>
    /// Demonstrates how components of the HandoverRequired can
    /// be accessed in the code.
    /// </summary>
    /// <param name="req">A HandoverRequired message.</param>
    public void AccessHandoverRequiredIEs(HandoverRequired req)
    {
        Console.WriteLine("\nAccessing IEs of the HandoverRequired message...\n");
        int ordinal = 0;
        foreach (HandoverRequired.ProtocolIEsType.Element ie in req.ProtocolIEs) {
            ++ordinal;
            Console.WriteLine("IE #{0}:\nid {1}\ncriticality {2}", ordinal, ie.Id, ie.Criticality);
            if (ie.Id == NGAPConstants.IdAMFUENGAPID)
            {
                AMFUENGAPID v = (AMFUENGAPID)ie.Value.Decoded;
                Console.WriteLine("value AMF-UE-NGAP-ID: {0}\n", v.Value);
            }
            else if (ie.Id == NGAPConstants.IdRANUENGAPID)
            {
                RANUENGAPID v = (RANUENGAPID)ie.Value.Decoded;
                Console.WriteLine("value RAN-UE-NGAP-ID: {0}\n", v.Value);
            }
            else if (ie.Id == NGAPConstants.IdHandoverType)
            {
                HandoverType v = (HandoverType)ie.Value.Decoded;
                Console.WriteLine("value HandoverType: {0}\n", v.Value);
            }
            else if (ie.Id == NGAPConstants.IdCause)
            {
                Cause v = (Cause)ie.Value.Decoded;
                Console.Write("value Cause: ");
                switch (v.Selected)
                {
                    case Cause.Id.TransportChosen:
                        Console.WriteLine("transport: {0}\n", v.Transport);
                        break;
                    case Cause.Id.RadioNetworkChosen:
                        Console.WriteLine("radioNetwork: {0}\n", v.RadioNetwork);
                        break;
                    case Cause.Id.ProtocolChosen:
                        Console.WriteLine("protocol: {0}\n", v.Protocol);
                        break;
                    case Cause.Id.NasChosen:
                        Console.WriteLine("nas: {0}\n", v.Nas);
                        break;
                    case Cause.Id.MiscChosen:
                        Console.WriteLine("misc: {0}\n", v.Misc);
                        break;
                    case Cause.Id.ChoiceExtensionsChosen:
                        Console.WriteLine("choice-Extensions {0}\n", PLACEHOLDER);
                        break;
                }
            }
            else if (ie.Id == NGAPConstants.IdTargetID) {
                TargetID v = (TargetID)ie.Value.Decoded;
                Console.Write("value TargetID: ");
                switch (v.Selected)
                {
                    case TargetID.Id.TargetRANNodeIDChosen:
                        Console.WriteLine("targetRANNodeID: ");
                        Console.WriteLine("  globalRANNodeID:");
                        switch (v.TargetRANNodeID.GlobalRANNodeID.Selected)
                        {
                            case GlobalRANNodeID.Id.GlobalGNBIDChosen:
                                Console.WriteLine("    globalGNB-ID:");
                                Console.WriteLine("      pLMNIdentity: {0}",
                                    BytesToString(v.TargetRANNodeID.GlobalRANNodeID.GlobalGNBID.PLMNIdentity));
                                Console.WriteLine("      gNB-ID:");
                                switch (v.TargetRANNodeID.GlobalRANNodeID.GlobalGNBID.GNBID.Selected)
                                {
                                    case GNBIDContainer.Id.GNBIDChosen:
                                        Console.WriteLine("        gNB-ID: {0}",
                                            BitsToString(v.TargetRANNodeID.GlobalRANNodeID.GlobalGNBID.GNBID.GNBID));
                                        break;
                                    case GNBIDContainer.Id.ChoiceExtensionsChosen:
                                        Console.WriteLine("        choice-Extensions: {0}", PLACEHOLDER);
                                        break;
                                }
                                if (v.TargetRANNodeID.GlobalRANNodeID.GlobalGNBID.IEExtensions != null)
                                    Console.WriteLine("      iE-Extensions: {0}", PLACEHOLDER);
                                break;
                            case GlobalRANNodeID.Id.GlobalNgENBIDChosen:
                                Console.WriteLine("    globalNgENB-ID: {0}", PLACEHOLDER);
                                break;
                            case GlobalRANNodeID.Id.GlobalN3IWFIDChosen:
                                Console.WriteLine("    globalN3IWF-ID: {0}", PLACEHOLDER);
                                break;
                            case GlobalRANNodeID.Id.ChoiceExtensionsChosen:
                                Console.WriteLine("    choice-Extensions: {0}", PLACEHOLDER);
                                break;
                        }
                        Console.WriteLine("  selectedTAI:");
                        Console.WriteLine("    pLMNIdentity: {0}", BytesToString(v.TargetRANNodeID.SelectedTAI.PLMNIdentity));
                        Console.WriteLine("    tAC         : {0}", BytesToString(v.TargetRANNodeID.SelectedTAI.TAC));
                        if (v.TargetRANNodeID.SelectedTAI.IEExtensions != null)
                            Console.WriteLine("    iE-Extensions: {0}", PLACEHOLDER);
                        if (v.TargetRANNodeID.IEExtensions != null)
                            Console.WriteLine("  iE-Extensions:{0}", PLACEHOLDER);
                        Console.WriteLine();
                        break;
                    case TargetID.Id.TargeteNBIDChosen:
                        Console.WriteLine("targetENB-ID: {0}\n", PLACEHOLDER);
                        break;
                    case TargetID.Id.ChoiceExtensionsChosen:
                        Console.WriteLine("choice-Extensions: {0}\n", PLACEHOLDER);
                        break;
                }
            }
            else if (ie.Id == NGAPConstants.IdDirectForwardingPathAvailability)
            {
                DirectForwardingPathAvailability v = (DirectForwardingPathAvailability)ie.Value.Decoded;
                Console.WriteLine("value DirectForwardingPathAvailability : {0}\n", v.Value);
            }
            else if (ie.Id == NGAPConstants.IdPDUSessionResourceListHORqd)
            {
                Console.WriteLine("value PDUSessionResourceListHORqd: {0}\n", PLACEHOLDER);
            }
            else if (ie.Id == NGAPConstants.IdSourceToTargetTransparentContainer)
            {
                SourceToTargetTransparentContainer v = (SourceToTargetTransparentContainer)ie.Value.Decoded;
                Console.WriteLine("value SourceToTarget-TransparentContainer: {0}\n", BytesToString(v.Value));
            }
            else {
                if (ie.Value.Decoded != null)
                    Console.WriteLine(ie.Value.Decoded);
                else
                    Console.WriteLine("IE left undecoded: {0}\n", BytesToString(ie.Value.Encoded));
            }
        }
    }

    /// <summary>
    /// A utility method to print bits of a BIT STRING.
    /// </summary>
    /// <param name="bitString">A value of BIT STRING</param>
    /// <returns></returns>
    private string BitsToString(BitString bitString)
    {
        StringBuilder sb = new StringBuilder(bitString.Length + 3);
        sb.Append("'");
        foreach (bool bit in bitString)
            sb.Append(bit ? "1" : "0");
        sb.Append("'B");
        return sb.ToString();
    }

    /// <summary>
    /// A utility method to print octets.
    /// </summary>
    /// <param name="bytes">The byte[] value </param>
    /// <returns></returns>
    private string BytesToString(byte[] bytes)
    {
        StringBuilder sb = new StringBuilder(2 * bytes.Length + 3);
        sb.Append("'");
        foreach (byte b in bytes)
            sb.Append(b.ToString("X2"));
        sb.Append("'H");
        return sb.ToString();
    }

    /// <summary>
    /// Dumps binary data to the TextWriter.
    /// </summary>
    /// <param name="data">The binary data</param>
    /// <param name="tty">The TextWriter where the hex dump is written</param>
    private void HexDump(byte[] data, TextWriter tty)
    {
        ValueNotationFormatter.Print(data, data.Length, tty);
    }

    /// <summary>
    /// Encodes and sends a message.
    /// </summary>
    void EncodeAndSend(NGAPPDU message)
    {
        // Assert the validity of the response messages
        codec.EncoderOptions.Validate = true;
        try
        {
            using (MemoryStream stream = new MemoryStream()) {
                Console.WriteLine("Encoding the NGAPPDU response PDU using memory stream...");
                codec.Encode(message, stream);
                Console.WriteLine("Encoded successfully.\n");
                Console.WriteLine("Printing the NGAPPDU response PDU in " + stream.Length + " bytes...");
                HexDump(stream.ToArray(), Console.Out);
            }
            Console.WriteLine("\nEncoding the NGAPPDU response PDU again using a class object...");
            byte[] encoded = codec.Encode(message);
            Console.WriteLine("Encoded successfully.\n");
            Console.WriteLine("Printing the NGAPPDU response PDU in " + encoded.Length + " bytes...");
            HexDump(encoded, Console.Out);
        }
        catch (Exception e)
        {
            throw new Exception("ERROR: Failed to encode.", e);
        }
    }
}