NAS/NASHelperNGAP_ServiceRequest.cpp at main · melrosenetworks/NAS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include "NASHelperNGAP.hpp"

namespace {

bool serviceRequestOptionalIsTlvE(std::uint8_t iei) {
    return iei == 0x71U;
}

bool serviceRequestOptionalIsTlv(std::uint8_t iei) {
    switch (iei) {
        case 0x40:
        case 0x50:
        case 0x25:
        case 0x29:
        case 0x28:
            return true;
        default:
            return false;
    }
}

}  // namespace

bool NASHelperNGAP::tryParseServiceRequestInformationElements(const std::uint8_t* const informationElements,
                                                              const std::size_t informationElementOctetCount,
                                                              ServiceRequestInformationElementsParse& out) {
    out = ServiceRequestInformationElementsParse{};

    if (informationElements == nullptr || informationElementOctetCount < 1U + 2U) {
        return false;
    }

    const std::uint8_t ngKsiService = informationElements[0];
    const std::uint16_t tmsiValueLength =
        static_cast<std::uint16_t>((static_cast<unsigned>(informationElements[1]) << 8U) |
                                   static_cast<unsigned>(informationElements[2]));

    const std::size_t mandatoryTotal = 1U + 2U + static_cast<std::size_t>(tmsiValueLength);
    if (mandatoryTotal < 3U || informationElementOctetCount < mandatoryTotal) {
        return false;
    }

    out.mandatory.ngksi_and_service_type_octet = ngKsiService;
    out.mandatory.five_g_s_tmsi_value = informationElements + 3U;
    out.mandatory.five_g_s_tmsi_value_octet_count = static_cast<std::size_t>(tmsiValueLength);
    out.mandatory.mandatory_total_octets = mandatoryTotal;

    std::size_t i = mandatoryTotal;
    while (i < informationElementOctetCount) {
        const std::uint8_t b = informationElements[i];

        if (serviceRequestOptionalIsTlvE(b)) {
            if (i + 3U > informationElementOctetCount) {
                break;
            }
            const std::uint16_t len =
                static_cast<std::uint16_t>((static_cast<unsigned>(informationElements[i + 1]) << 8U) |
                                           static_cast<unsigned>(informationElements[i + 2]));
            const std::size_t chunk = 3U + static_cast<std::size_t>(len);
            if (i + chunk > informationElementOctetCount || i + chunk < i) {
                break;
            }
            ServiceRequestOptionalInformationElement opt{};
            opt.iei = b;
            opt.encoding = ServiceRequestOptionalInformationElement::Encoding::TlvE;
            opt.value.assign(informationElements + i + 3, informationElements + i + 3 + len);
            out.optionals.push_back(std::move(opt));
            i += chunk;
            continue;
        }

        if (serviceRequestOptionalIsTlv(b)) {
            if (i + 2U > informationElementOctetCount) {
                break;
            }
            const std::uint8_t len = informationElements[i + 1];
            const std::size_t chunk = 2U + static_cast<std::size_t>(len);
            if (i + chunk > informationElementOctetCount || i + chunk < i) {
                break;
            }
            ServiceRequestOptionalInformationElement opt{};
            opt.iei = b;
            opt.encoding = ServiceRequestOptionalInformationElement::Encoding::Tlv;
            opt.value.assign(informationElements + i + 2, informationElements + i + 2 + len);
            out.optionals.push_back(std::move(opt));
            i += chunk;
            continue;
        }

        out.unparsed_begin = informationElements + i;
        out.unparsed_octet_count = informationElementOctetCount - i;
        break;
    }

    out.ok = true;
    return true;
}