LTE S1AP 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.                                            //
///////////////////////////////////////////////////////////////////////////////

//
// Demonstrates part of the LTE S1AP protocol.
//


// Classes generated from ASN.1 specification.
using S1ap;
using S1ap.S1APPDUDescriptions;
using S1ap.S1APPDUContents;
using S1ap.S1APContainers;
using S1ap.S1APIEs;

// 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] : "../../";
            Ts1ap ts1ap = new Ts1ap();
            ts1ap.Process(dataDir, "S1AP-PDU_HandoverRequest_bin.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 Ts1ap
{
    PerAlignedCodec codec = new PerAlignedCodec();
    /// <summary>
    /// Processes a file with encoded S1AP PDU.
    /// </summary>
    public void Process(String dataDir, String fileName)
    {
        try
        {
            String fullPath = Path.Combine(dataDir, fileName);
            S1APPDU req = DecodeRequest(fullPath);
            Console.WriteLine("\nPrinting the PER-Decoded S1APPDU PDU...\n");
            ValueNotationFormatter.Print(req, Console.Out);
            S1APPDU res = CreateResponse(req);
            if (res != null) {
                Console.WriteLine("\nPrinting the created S1APPDU 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 S1APPDU response PDUs.
    /// </summary>
    S1APPDU CreateResponse(S1APPDU request)
    {
        // Check that the message contains InitiatingMessage.
        if (request.Selected != S1APPDU.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;
                    AccessHandoverRequestIEs(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 S1APPDU CreateHandoverCommand(HandoverRequired req)
    {
        Console.WriteLine("\nCreating a HandoverCommand S1APPDU 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 == S1ap.S1APConstants.Values.IdMMEUES1APID ||
                ie.Id == S1ap.S1APConstants.Values.IdENBUES1APID ||
                ie.Id == S1ap.S1APConstants.Values.IdHandoverType)
            {
                response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
                {
                    Id = ie.Id,
                    Criticality = ie.Criticality,
                    Value = ie.Value
                });
            }
        }
        // Add E-RABList IE to outcome message
        ERABList erabList = new ERABList();
        ERABItem erabItem = new ERABItem()
        {
            Cause = new Cause() { RadioNetwork = CauseRadioNetwork.X2HandoverTriggered },
            ERABID = 13
        };
        ERABList.Element erabListElement = new ERABList.Element()
        {
            Id = S1ap.S1APConstants.Values.IdERABItem,
            Criticality = S1ap.S1APCommonDataTypes.Criticality.Ignore,
            Value = new OpenType(erabItem)
        };
        erabList.Add(erabListElement);
        response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
        {
            Id = S1ap.S1APConstants.Values.IdERABtoReleaseListHOCmd,
            Criticality = S1ap.S1APCommonDataTypes.Criticality.Ignore,
            Value = new OpenType(new ERABListPdu() { Value = erabList })
        });
        // Add Target-ToSource-TransparentContainer IE to outcome message
        TargetToSourceTransparentContainer trValue = new TargetToSourceTransparentContainer()
        {
            Value = new byte[] { (byte)0x55 }
        };
        response_IEs.Add(new HandoverCommand.ProtocolIEsType.Element()
        {
            Id = S1ap.S1APConstants.Values.IdTargetToSourceTransparentContainer,
            Criticality = S1ap.S1APCommonDataTypes.Criticality.Reject,
            Value = new OpenType(trValue)
        });
        HandoverCommand handoverCommand = new HandoverCommand()
        {
            ProtocolIEs = response_IEs
        };
        SuccessfulOutcome successfulOutcome = new SuccessfulOutcome()
        {
            ProcedureCode = S1ap.S1APConstants.Values.IdHandoverPreparation,
            Criticality = S1ap.S1APCommonDataTypes.Criticality.Reject,
            Value = new OpenType(handoverCommand)
        };
        S1APPDU pdu = new S1APPDU();
        pdu.SuccessfulOutcome = successfulOutcome;
        Console.WriteLine("Created the S1APPDU response PDU successfully.\n");
        return pdu;
    }

    /// <summary>
    /// Decodes an S1APPDU request PDU from a file.
    /// </summary>
    S1APPDU 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 S1APPDU request PDU from the file " + fileName + "...");
            S1APPDU msg = new S1APPDU();
            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>() {
        {S1ap.S1APConstants.Values.IdHandoverPreparation, ProcedureCode.HandoverRequired}
    };

    /// <summary>
    /// Demonstrates how components of the HandoverRequired can
    /// be accessed in the code.
    /// </summary>
    /// <param name="req">A HandoverRequired message.</param>
    public void AccessHandoverRequestIEs(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 == S1ap.S1APConstants.Values.IdMMEUES1APID) {
                MMEUES1APID v = (MMEUES1APID)ie.Value.Decoded;
                Console.WriteLine("value MME-UE-S1AP-ID: {0}\n", v.Value);
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdENBUES1APID) {
                ENBUES1APID v = (ENBUES1APID)ie.Value.Decoded;
                Console.WriteLine("value ENB-UE-S1AP-ID: {0}\n", v.Value);
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdHandoverType) {
                HandoverType v = (HandoverType)ie.Value.Decoded;
                Console.WriteLine("value HandoverType: {0}\n", v.Value);
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdTargetID) {
                TargetID v = (TargetID)ie.Value.Decoded;
                CGI cgi = (CGI)v.CGI;
                Console.WriteLine("    pLMNidentity: {0}", BitConverter.ToString(cgi.PLMNidentity));
                Console.WriteLine("    lac         : {0}", BitConverter.ToString(cgi.LAC));
                Console.WriteLine("    cI          : {0}", BitConverter.ToString(cgi.CI));
                Console.WriteLine("    rAC         : {0}\n", BitConverter.ToString(cgi.RAC));
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdCause) {
                Cause v = (Cause)ie.Value.Decoded;
                Console.WriteLine("value Cause: {0}\n", v);
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdDirectForwardingPathAvailability) {
                DirectForwardingPathAvailability v = (DirectForwardingPathAvailability)ie.Value.Decoded;
                Console.WriteLine("value Direct-Forwarding-Path-Availability : {0}\n", v.Value);
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdSRVCCHOIndication) {
                SRVCCHOIndication v = (SRVCCHOIndication)ie.Value.Decoded;
                Console.WriteLine("value SRVCCHOIndication: {0}\n", v.Value);
            }
            else if (ie.Id == S1ap.S1APConstants.Values.IdSourceToTargetTransparentContainer) {
                SourceToTargetTransparentContainer v = (SourceToTargetTransparentContainer)ie.Value.Decoded;
                Console.WriteLine("value Source-ToTarget-TransparentContainer: {0}\n", v.Value);
            }
            else {
                if (ie.Value.Decoded != null)
                    Console.WriteLine(ie.Value.Decoded);
                else
                    Console.WriteLine("IE left undecoded: {0}\n", BitConverter.ToString(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);
        foreach (bool bit in bitString)
            sb.Append(bit ? "1" : "0");
        return sb.ToString();
    }

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