NG-RAN E1AP C# Sample Code Using OSS ASN.1 Tools

///////////////////////////////////////////////////////////////////////////////
// Copyright (C) ###RELEASE_YEAR### 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.                                            //
///////////////////////////////////////////////////////////////////////////////

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


// Classes generated from ASN.1 specification.
using E1ap;
using E1ap.E1APPDUDescriptions;
using E1ap.E1APPDUContents;
using E1ap.E1APContainers;
using E1APConstants = E1ap.E1APConstants.Values;
using E1ap.E1APIEs;

// 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] : "../../";
            Te1ap te1ap = new Te1ap();
            te1ap.Process(dataDir, "E1AP-PDU_Reset.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 Te1ap
{
    PerAlignedCodec codec = new PerAlignedCodec();
    /// <summary>
    /// Processes a file with encoded E1AP PDU.
    /// </summary>
    public void Process(String dataDir, String fileName)
    {
        try
        {
            String fullPath = Path.Combine(dataDir, fileName);
            E1APPDU req = DecodeRequest(fullPath);
            Console.WriteLine("\nPrinting the PER-Decoded E1APPDU PDU...\n");
            ValueNotationFormatter.Print(req, Console.Out);
            E1APPDU res = CreateResponse(req);
            if (res != null) {
                Console.WriteLine("\nPrinting the created E1APPDU 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 E1APPDU response PDUs.
    /// </summary>
    E1APPDU CreateResponse(E1APPDU request)
    {
        // Check that the message contains InitiatingMessage.
        if (request.Selected != E1APPDU.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.Reset:
                {
                    Reset req = (Reset)msg.Value.Decoded;
                    AccessResetIEs(req);
                    return CreateResetAcknowledge(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 ResetAcknowledge PDU.
    /// </summary>
    public E1APPDU CreateResetAcknowledge(Reset req)
    {
        Console.WriteLine("\nCreating a ResetAcknowledge E1APPDU PDU message...");
        Reset.ProtocolIEsType request_IEs = req.ProtocolIEs;

        if (request_IEs == null || request_IEs.Count == 0)
        {
            Console.WriteLine("No IEs in the HandoverRequired message.");
            return null;
        }
        ResetAcknowledge.ProtocolIEsType response_IEs = new ResetAcknowledge.ProtocolIEsType();
        // Add TransactionID to outcome message
        response_IEs.Add(new ResetAcknowledge.ProtocolIEsType.Element()
        {
            Id = E1APConstants.IdTransactionID,
            Criticality = E1ap.E1APCommonDataTypes.Criticality.Reject,
            Value = new OpenType(
                new TransactionID()
                {
                    Value = 7
                })
        });
        ResetAcknowledge resetAcknowledge = new ResetAcknowledge()
        {
            ProtocolIEs = response_IEs
        };
        SuccessfulOutcome successfulOutcome = new SuccessfulOutcome()
        {
            ProcedureCode = E1APConstants.IdReset,
            Criticality = E1ap.E1APCommonDataTypes.Criticality.Reject,
            Value = new OpenType(resetAcknowledge)
        };
        E1APPDU pdu = new E1APPDU()
        {
            SuccessfulOutcome = successfulOutcome
        };
        Console.WriteLine("Created the E1APPDU response PDU successfully.\n");
        return pdu;
    }

    /// <summary>
    /// Decodes an E1APPDU request PDU from a file.
    /// </summary>
    E1APPDU 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 E1APPDU request PDU from the file " + fileName + "...");
            E1APPDU msg = new E1APPDU();
            codec.Decode(stream, msg);
            Console.WriteLine("PDU decoded successfully.");
            return msg;
        }
    }

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

    static Dictionary<int, ProcedureCode> ProcedureCodes = new Dictionary<int, ProcedureCode>() {
        {E1APConstants.IdReset, ProcedureCode.Reset}
    };

    /// <summary>
    /// Demonstrates how components of the Reset can
    /// be accessed in the code.
    /// </summary>
    /// <param name="req">A Reset message.</param>
    public void AccessResetIEs(Reset req)
    {
        Console.WriteLine("\nAccessing IEs of the Reset message...\n");
        int ordinal = 0;
        foreach (Reset.ProtocolIEsType.Element ie in req.ProtocolIEs) {
            ++ordinal;
            Console.WriteLine("IE #{0}:\nid {1}\ncriticality {2}", ordinal, ie.Id, ie.Criticality);
            if (ie.Id == E1APConstants.IdTransactionID) {
                TransactionID v = (TransactionID)ie.Value.Decoded;
                Console.WriteLine("value TransactionID: {0}\n", v.Value);
            }
            else if (ie.Id == E1APConstants.IdResetType) {
                ResetType v = (ResetType)ie.Value.Decoded;
                Console.Write("value ResetType: ");
                switch (v.Selected)
                {
                    case ResetType.Id.E1InterfaceChosen:
                        Console.WriteLine("e1-interface: {0}\n", v.E1Interface);
                        break;
                    case ResetType.Id.PartOfE1InterfaceChosen:
                        {
                            Console.WriteLine("partOfE1-Interface: ");
                            var uE_ass_Con = v.PartOfE1Interface;
                            int n = 0;
                            foreach (var entry in uE_ass_Con)
                            {
                                Console.WriteLine("    #{0}:\n    id {1}\n    criticality {2}",
                                    ++n, entry.Id, entry.Criticality);
                                UEAssociatedLogicalE1ConnectionItem item =
                                    (UEAssociatedLogicalE1ConnectionItem)entry.Value.Decoded;
                                Console.WriteLine("    value GNB-CU-CP-UE-E1AP-ID: {0}", item.GNBCUCPUEE1APID);
                                Console.WriteLine("    value GNB-CU-UP-UE-E1AP-ID: {0}\n", item.GNBCUUPUEE1APID);
                            }
                        }
                        break;
                }
            }
            else if (ie.Id == E1APConstants.IdCause)
            {
                Cause v = (Cause)ie.Value.Decoded;
                Console.Write("value Cause: ");
                switch (v.Selected)
                {
                    case Cause.Id.RadioNetworkChosen:
                        Console.WriteLine("radioNetwork: {0}\n", v.RadioNetwork);
                        break;
                    case Cause.Id.TransportChosen:
                        Console.WriteLine("transport: {0}\n", v.Transport);
                        break;
                    case Cause.Id.ProtocolChosen:
                        Console.WriteLine("protocol: {0}\n", v.Protocol);
                        break;
                    case Cause.Id.MiscChosen:
                        Console.WriteLine("misc: {0}\n", v.Misc);
                        break;
                }
            }
            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 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(E1APPDU message)
    {
        // Assert the validity of the response messages
        codec.EncoderOptions.Validate = true;
        try
        {
            using (MemoryStream stream = new MemoryStream()) {
                Console.WriteLine("Encoding the E1APPDU response PDU using memory stream...");
                codec.Encode(message, stream);
                Console.WriteLine("Encoded successfully.\n");
                Console.WriteLine("Printing the E1APPDU response PDU in " + stream.Length + " bytes...");
                HexDump(stream.ToArray(), Console.Out);
            }
            Console.WriteLine("\nEncoding the E1APPDU response PDU again using a class object...");
            byte[] encoded = codec.Encode(message);
            Console.WriteLine("Encoded successfully.\n");
            Console.WriteLine("Printing the E1APPDU response PDU in " + encoded.Length + " bytes...");
            HexDump(encoded, Console.Out);
        }
        catch (Exception e)
        {
            throw new Exception("ERROR: Failed to encode.", e);
        }
    }
}