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

/*
 * Demonstrates work with data for 5G NGAP protocol
 */

import java.io.*;

import com.oss.asn1.*;
import com.oss.util.*;

import ngap.*;
import ngap.oss_ngap_ngap_commondatatypes.*;
import ngap.oss_ngap_ngap_constants.*;
import ngap.oss_ngap_ngap_containers.*;
import ngap.oss_ngap_ngap_ies.*;
import ngap.oss_ngap_ngap_pdu_contents.*;
import ngap.oss_ngap_ngap_pdu_descriptions.*;

public class Tngap {
    static Coder coder;
    static String border = "-------------------------------------------------------";
    /* Names of Criticality values */
    static String[] Criticalities = { "reject", "ignore", "notify" };

    /* Names of HandoverType values */
    static String HandoverType[] = {
	"intra5gs", "fivegs-to-eps", "eps-to-5gs", "unknown"
    };

    /*
     * Deserializes and prints input messages, creates and prints successful
     * outcome messages
     */
    public static void main(String[] args) throws java.io.FileNotFoundException, Exception
    {
	// Initialize the project
	try {
	    Ngap.initialize();
	} catch (Exception e) {
	    System.out.println("Initialization exception: " + e);
	    System.exit(1);
	}

	coder = Ngap.getPERAlignedCoder();
	coder.enableAutomaticEncoding();
	coder.enableAutomaticDecoding();
	coder.enableEncoderDebugging();
	coder.enableDecoderDebugging();

	// An optional parameter includes the path to all the files that are used by
	// the program.
	String path = (args.length > 0) ? args[0] : null;

	try {
	    testNGAP(path, "NGAP-PDU_HandoverRequest.per");
	} catch (Exception e) {
	    System.out.println(e);
	    System.exit(1);
	}

	System.out.println("\nTesting successful");
    }

    /*
     * testNGAP() is used to test NGAP message, the input serialized pdu is
     * deserialized and printed, then an outcome message is created, printed
     * and encoded.
     */
    static void testNGAP(String path, String filename) throws IOException, Exception
    {
	OSS_NGAP_PDU request;
	File file = new File(path, filename);
	if (!file.exists()) {
	    throw new IOException("Failed to open the " + file.toString() + " file. " +
		"Restart the sample program using as input parameter the name of the directory " +
		"where the '" + file.getName() + "' file is located.\n");
	}
	FileInputStream source = new FileInputStream(file);

	System.out.println("============================================================================");
	/* Read serialized message from file */
	System.out.println("Read encoding from file: " + filename + "\n");

	System.out.println("Deserialize request");
	System.out.println(border);
	/* Deserialize input message */
        request = (OSS_NGAP_PDU)coder.decode(source, new OSS_NGAP_PDU());
	source.close();
	System.out.println("\nDeserialized request");
	System.out.println(border);
	System.out.println(request);
	/* Parse and print input message */
	printHandoverRequiredMsg(request);
	/* Create successful outcome message */
	OSS_NGAP_PDU response = createSuccessResponse(request);

	/* Print outcome message */
	System.out.println(response);
	System.out.println("Serialize response");
	System.out.println(border);
	/* Serialize outcome message */
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	try {
	    coder.encode(response, out);
	} catch (Exception e) {
	    System.out.println("Encoding failed: " + e);
	    System.exit(1);
	}

	/* Print serialized outcome message */
	System.out.println("\nSerialized response "
				+ "(" + out.size() + " bytes):");
	System.out.println(HexTool.getHex(out.toByteArray()));
    }

    /*
     * Prints NGAP pdu which contains HandoverRequired message. The
     * function is not intended to handle other types of messages.
     */
    static void printHandoverRequiredMsg(OSS_NGAP_PDU pdu) throws Exception
    {
	OSS_NGAP_HandoverRequired hr_value;
	System.out.println("\nGet message information");
	System.out.println(border);
	/* Get identifier of message stored in PDU */
	if (!pdu.hasInitiatingMessage())
	    throw new Exception("Unexpected type of message");

	OpenType msg_value = ((OSS_NGAP_InitiatingMessage)pdu.getChosenValue()).getValue();
	if (msg_value.getDecodedValue() != null) {
	    if (msg_value.getDecodedValue() instanceof OSS_NGAP_HandoverRequired)
		hr_value = (OSS_NGAP_HandoverRequired)msg_value.getDecodedValue();
	    else
		throw new Exception("Incorrect message");
	} else
	    throw new Exception("Incorrect message");

	System.out.println("Message type is HandoverRequired\n");

	if (hr_value.getProtocolIEs() == null)
	    throw new Exception("Incorrect message");

	printProtocolIEs(hr_value.getProtocolIEs(), 0);
    }

    /*
     * Creates NGAP successful outcome message for given
     * HandoverRequired request.
     */
    static OSS_NGAP_PDU createSuccessResponse(OSS_NGAP_PDU request) throws Exception
    {
	if (!request.hasInitiatingMessage())
	    throw new Exception("Unexpected type of message");

	OpenType msg_value = ((OSS_NGAP_InitiatingMessage)
	    request.getChosenValue()).getValue();
	OSS_NGAP_HandoverRequired hr_value =
	    (OSS_NGAP_HandoverRequired)msg_value.getDecodedValue();

	if (hr_value == null || msg_value.getEncodedValue() != null)
	    throw new Exception("Unexpected HandoverRequired request data");

	if (hr_value.getProtocolIEs() == null || hr_value.getProtocolIEs().getSize() == 0)
	    throw new Exception("No IEs in HandoverRequired request");

	OSS_NGAP_HandoverRequired.OSS_NGAP_HRequiredIEs reqies = hr_value.getProtocolIEs();

	System.out.println("Create response");
	System.out.println(border);
	/*
         * Create successful outcome message from initiating message. Copy
         * some IEs from input to output.
         */
        OSS_NGAP_HandoverCommand.OSS_NGAP_HCommandIEs respies = new OSS_NGAP_HandoverCommand.OSS_NGAP_HCommandIEs();
    	OSS_NGAP_ProtocolIE_Field element;

        for (int i = 0; i < reqies.getSize(); i++) {
    	    if (reqies.get(i).getId().equalTo(
    		    OSS_NGAP_NGAP_Constants.OSS_NGAP_id_AMF_UE_NGAP_ID)
    		    || reqies.get(i).getId().equalTo(
    		    OSS_NGAP_NGAP_Constants.OSS_NGAP_id_RAN_UE_NGAP_ID)
    		    || reqies.get(i).getId().equalTo(
    		    OSS_NGAP_NGAP_Constants.OSS_NGAP_id_HandoverType)
    		    ) {
		element = (OSS_NGAP_ProtocolIE_Field)reqies.get(i).clone();
		respies.add(element);
	    /* Add TargetToSource-TransparentContainer IE to outcome message */
	    } else if (reqies.get(i).getId().equalTo(
    		OSS_NGAP_NGAP_Constants.OSS_NGAP_id_SourceToTarget_TransparentContainer)) {
    		OpenType opValue = reqies.get(i).getValue();
		OSS_NGAP_TargetToSource_TransparentContainer trValue =
    		    new OSS_NGAP_TargetToSource_TransparentContainer(
			((OSS_NGAP_SourceToTarget_TransparentContainer)opValue.getDecodedValue()).byteArrayValue());
		element = new OSS_NGAP_ProtocolIE_Field(
		    OSS_NGAP_NGAP_Constants.OSS_NGAP_id_TargetToSource_TransparentContainer,
		    OSS_NGAP_Criticality.reject,
		    new OpenType(trValue));
		respies.add(element);
	    }
	}

	OSS_NGAP_Criticality criticality;
	OSS_NGAP_ProcedureCode procedureCode = ((OSS_NGAP_InitiatingMessage)
			request.getChosenValue()).getProcedureCode();
	criticality = OSS_NGAP_Criticality.reject;
    	OSS_NGAP_HandoverCommand handoverCommand =
	    new OSS_NGAP_HandoverCommand(respies);
	OSS_NGAP_SuccessfulOutcome successfulOutcome =
	    new OSS_NGAP_SuccessfulOutcome(
	        procedureCode, criticality, new OpenType(handoverCommand));
	OSS_NGAP_PDU response =
	    OSS_NGAP_PDU.createOSS_NGAP_PDUWithSuccessfulOutcome(successfulOutcome);
	return response;
    }

    /*
     * Prints ProtocolIE_Container data.
     */
    static void printProtocolIEs(OSS_NGAP_HandoverRequired.OSS_NGAP_HRequiredIEs ies, int indent)
    {
	System.out.println("protocolIEs includes the following IEs:\n");
	indent++;
	/* Print each IE */
        for (int i = 0; i < ies.getSize(); i++) {
	    OSS_NGAP_ProtocolIE_Field field =
		(OSS_NGAP_ProtocolIE_Field )ies.get(i).clone();
	    OpenType value = field.getValue();
	    long fieldId = field.getId().longValue();
	    printIndent(indent++);
	    System.out.println("#" + (i + 1) + ": id = " + fieldId +
				", criticality = " + Criticalities[(int)field.getCriticality().longValue()]);

	    /* Print AMF-UE-NGAP-ID IE */
	    printIndent(indent);
    	    if (field.getId().equalTo(OSS_NGAP_NGAP_Constants.OSS_NGAP_id_AMF_UE_NGAP_ID)) {
		System.out.println("value AMF-UE-NGAP-ID: " +
		    ((OSS_NGAP_AMF_UE_NGAP_ID)value.getDecodedValue()).longValue());
	    /* RAN-UE-NGAP-ID IE */
    	    } else if (field.getId().equalTo(OSS_NGAP_NGAP_Constants.OSS_NGAP_id_RAN_UE_NGAP_ID)) {
		System.out.println("value RAN-UE-NGAP-ID: " +
		    ((OSS_NGAP_RAN_UE_NGAP_ID)value.getDecodedValue()).longValue());
	    /* HandoverType IE */
    	    } else if (field.getId().equalTo(OSS_NGAP_NGAP_Constants.OSS_NGAP_id_HandoverType)) {
		System.out.println("value HandoverType: " +
		    HandoverType[(int)((OSS_NGAP_HandoverType)value.getDecodedValue()).longValue()]);
	    /* Cause IE */
    	    } else if (field.getId().equalTo(OSS_NGAP_NGAP_Constants.OSS_NGAP_id_Cause)) {
		OSS_NGAP_Cause pcause = (OSS_NGAP_Cause)value.getDecodedValue();

		/*
		 * Named values can be printed below instead of numbers for all
		 * Cause components
		 */
		System.out.print("value Cause: ");
		/* radioNetwork */
		if (pcause.hasRadioNetwork())
		    System.out.println("radioNetwork: " +
			((OSS_NGAP_CauseRadioNetwork)pcause.getChosenValue()).longValue());
		/* transport */
		else if (pcause.hasTransport())
		    System.out.println("transport: " +
			((OSS_NGAP_CauseTransport)pcause.getChosenValue()).longValue());
		/* nas */
		else if (pcause.hasNas())
		    System.out.println("nas: " +
			((OSS_NGAP_CauseNas)pcause.getChosenValue()).longValue());
		/* protocol */
		else if (pcause.hasProtocol())
		    System.out.println("protocol: " +
			((OSS_NGAP_CauseProtocol)pcause.getChosenValue()).longValue());
		/* misc */
		else if (pcause.hasMisc())
		    System.out.println("misc: " +
			((OSS_NGAP_CauseMisc)pcause.getChosenValue()).longValue());
		else if (pcause.hasChoice_Extensions())
			System.out.println("choice-Extensions --<Not implemented>--");
	    /* TargetID IE */
    	    } else if (field.getId().equalTo(OSS_NGAP_NGAP_Constants.OSS_NGAP_id_TargetID)) {
		OSS_NGAP_TargetID ptarget = (OSS_NGAP_TargetID)value.getDecodedValue();
		System.out.print("value TargetID : ");
		indent++;
		/* targetRANNodeID */
		if (ptarget.hasTargetRANNodeID()) {
		    OSS_NGAP_TargetRANNodeID targetRANNodeID =
		        (OSS_NGAP_TargetRANNodeID)ptarget.getChosenValue();
		    printDataWithIndent(indent, "globalRANNodeID :");
		    indent++;
		    if (targetRANNodeID.getGlobalRANNodeID().hasGlobalGNB_ID()) {
			printDataWithIndent(indent,"globalGNB-ID:");
			indent++;
			/* pLMNidentity */
			printDataWithIndent(indent, "pLMNIdentity: " +
			    toHstring(targetRANNodeID.getGlobalRANNodeID().getGlobalGNB_ID().getPLMNIdentity().byteArrayValue()));
			/* gNB-ID */
			printIndent(indent);
			System.out.print("gNB-ID :");
			if (targetRANNodeID.getGlobalRANNodeID().getGlobalGNB_ID().getGNB_ID().hasGNB_ID()) {
			    printDataWithIndent(indent, "gNB-ID: " +
				toHstring(targetRANNodeID.getGlobalRANNodeID().getGlobalGNB_ID().getGNB_ID().getGNB_ID().byteArrayValue()));
			} else if (targetRANNodeID.getGlobalRANNodeID().getGlobalGNB_ID().getGNB_ID().hasChoice_Extensions())
			    System.out.println("choice-Extensions --<Not implemented>--");
			indent--;
		    } else if (targetRANNodeID.getGlobalRANNodeID().hasGlobalNgENB_ID()) {
			System.out.println("globalNgENB-ID --<Not implemented>--");
		    } else if (targetRANNodeID.getGlobalRANNodeID().hasGlobalN3IWF_ID()) {
			System.out.println("globalN3IWF-ID --<Not implemented>--");
		    } else if (targetRANNodeID.getGlobalRANNodeID().hasChoice_Extensions())
			System.out.println("choice-Extensions --<Not implemented>--");

		    printDataWithIndent(indent, "selectedTAI: ");
		    indent++;
		    printDataWithIndent(indent, "pLMNIdentity: " +
			toHstring(targetRANNodeID.getSelectedTAI().getPLMNIdentity().byteArrayValue()));
		    printDataWithIndent(indent, "tAC: " +
			toHstring(targetRANNodeID.getSelectedTAI().getTAC().byteArrayValue()));
		    indent--;
		    /* iE_Extensions is optional */
		    if (targetRANNodeID.hasIE_Extensions())
			printProtocolExtensions(
			    targetRANNodeID.getIE_Extensions(), indent);
		    indent--;
		/* targeteNB-ID */
		} else if (ptarget.hasTargeteNB_ID()) {
		    OSS_NGAP_TargeteNB_ID targeteNB_ID =
			(OSS_NGAP_TargeteNB_ID)ptarget.getChosenValue();
		    System.out.println("targeteNB-ID :");
		    /* global-ENB-ID */
		    printDataWithIndent(indent, "globalENB-ID: ");
		    indent++;
		    /* selected-EPS-TAI */
		    printDataWithIndent(indent, "selected-EPS-TAI: ");

		    if (targeteNB_ID.getGlobalENB_ID().hasIE_Extensions())
			printProtocolExtensions(
			    targeteNB_ID.getGlobalENB_ID().getIE_Extensions(), indent);

		    indent--;
		/* choice-Extensions */
		} else if (ptarget.hasChoice_Extensions()) {
		    System.out.println("choice-Extensions --<Not implemented>--");
		}
	    indent--;

	    /* DirectForwardingPathAvailability IE */
    	    } else if (field.getId().equalTo(OSS_NGAP_NGAP_Constants.OSS_NGAP_id_DirectForwardingPathAvailability)) {
		System.out.println("value DirectForwardingPathAvailability: " +
		    ((OSS_NGAP_DirectForwardingPathAvailability)value.getDecodedValue()).longValue());
	    /* other IEs are printed as ASN.1 value notation */
	    } else if (value.getDecodedValue() != null) {
		System.out.print(value.getDecodedValue());
	    } else
		System.out.println("PDU is not decoded");
	    System.out.println();
	    indent--;
	}
    }

    /*
     * Prints ProtocolExtensionContainer data.
     */
    static void printProtocolExtensions(
	    OSS_NGAP_ProtocolExtensionContainer ie_ext, int indent)
    {
	printDataWithIndent(indent++, "iE-Extensions includes the following IEs:");
        for (int i = 0; i < ie_ext.getSize(); i++) {
    	    OSS_NGAP_ProtocolExtensionField field = ie_ext.get(i);
	    OpenType value = field.getExtensionValue();
	    long fieldId = field.getId().longValue();
	    printIndent(indent++);
	    System.out.println("#" + (i + 1) + ": id = " + fieldId +
				", criticality = " +
				Criticalities[(int)field.getCriticality().longValue()]);
	    if (value.getDecodedValue() != null)
		System.out.println(value.getDecodedValue());
	    else
		System.out.println("PDU is not decoded");
	}
    }

    /*
     * Helper method. Converts byte[] array to the Hstring format, like '12345'H.
     */
    static String toHstring(byte[] value)
    {
	return "'" + HexTool.getHex(value) + "'H";
    }

    /*
     * Performs indentation.
     * @param indentlevel indentation level.
     */
    public static void printIndent(int indentlevel)
    {
	for (int i = 0; i < indentlevel; i++)
	    System.out.print(' ');
    }

    /*
     * Print indentation with following data.
     */
    public static void printDataWithIndent(int indentlevel, Object data)
    {
	printIndent(indentlevel);
	System.out.println(data);
    }
}