Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 1 | module STP_Tests_M3UA { |
| 2 | |
| 3 | /* Osmocom STP test suite in in TTCN-3 |
| 4 | * (C) 2019 Harald Welte <laforge@gnumonks.org> |
| 5 | * All rights reserved. |
| 6 | * |
| 7 | * Released under the terms of GNU General Public License, Version 2 or |
| 8 | * (at your option) any later version. |
| 9 | * |
| 10 | * SPDX-License-Identifier: GPL-2.0-or-later |
| 11 | */ |
| 12 | |
| 13 | friend module STP_Tests; |
| 14 | |
| 15 | import from General_Types all; |
| 16 | import from Osmocom_Types all; |
| 17 | import from IPL4asp_Types all; |
| 18 | |
| 19 | import from Osmocom_VTY_Functions all; |
| 20 | |
| 21 | import from M3UA_Types all; |
| 22 | import from M3UA_Templates all; |
| 23 | import from M3UA_CodecPort all; |
| 24 | import from M3UA_CodecPort_CtrlFunct all; |
| 25 | |
| 26 | import from M3UA_Emulation all; |
| 27 | import from MTP3asp_Types all; |
| 28 | import from MTP3asp_PortType all; |
| 29 | |
| 30 | import from SCCP_Types all; |
| 31 | import from SCCP_Templates all; |
| 32 | import from SCCPasp_Types all; |
| 33 | import from SCCP_Emulation all; |
| 34 | |
| 35 | import from STP_Tests_Common all; |
| 36 | |
| 37 | modulepar { |
| 38 | integer mp_stp_m3ua_port := 2905; |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 39 | integer mp_stp_m3ua_clnt_port := 2906; |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 40 | integer mp_local_m3ua_port := 9999; |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 41 | integer mp_recovery_timeout_msec := 2000; |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 42 | } |
| 43 | |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 44 | private const integer NR_M3UA := 3; /* number of M3UA clients in ATS */ |
| 45 | private const integer NR_M3UA_SRV := 1; /* number of M3UA servres in ATS */ |
| 46 | |
| 47 | private function M3UA_SRV(integer idx) return integer { |
| 48 | return NR_M3UA+idx; |
| 49 | } |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 50 | |
| 51 | type component RAW_M3UA_CT extends Test_CT { |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 52 | port M3UA_CODEC_PT M3UA[NR_M3UA+NR_M3UA_SRV]; |
| 53 | var integer g_m3ua_conn_id[NR_M3UA+NR_M3UA_SRV]; |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | private template PortEvent tr_SctpAssocChange := { |
| 57 | sctpEvent := { |
| 58 | sctpAssocChange := ? |
| 59 | } |
| 60 | } |
| 61 | private template PortEvent tr_SctpPeerAddrChange := { |
| 62 | sctpEvent := { |
| 63 | sctpPeerAddrChange := ? |
| 64 | } |
| 65 | } |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 66 | private template PortEvent tr_SctpConnOpened := { |
| 67 | connOpened := ? |
| 68 | } |
| 69 | |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 70 | |
| 71 | private altstep as_m3ua_sctp() runs on RAW_M3UA_CT { |
| 72 | [] any from M3UA.receive(tr_SctpAssocChange) { repeat; } |
| 73 | [] any from M3UA.receive(tr_SctpPeerAddrChange) { repeat; } |
| 74 | } |
| 75 | |
| 76 | friend function f_M3UA_send(integer idx, template (present) PDU_M3UA msg, template integer stream := 0) |
| 77 | runs on RAW_M3UA_CT { |
| 78 | M3UA[idx].send(t_M3UA_Send(g_m3ua_conn_id[idx], msg, stream)); |
| 79 | } |
| 80 | |
| 81 | friend function f_M3UA_exp(integer idx, template (present) PDU_M3UA msg) runs on RAW_M3UA_CT { |
| 82 | var M3UA_RecvFrom rx; |
| 83 | alt { |
| 84 | [] M3UA[idx].receive(t_M3UA_RecvFrom(msg)) { |
| 85 | setverdict(pass); |
| 86 | } |
| 87 | [] M3UA[idx].receive(t_M3UA_RecvFrom(?)) -> value rx { |
| 88 | setverdict(fail, "Received unexpected M3UA[", idx, "] ", rx, |
| 89 | "while waiting for ", msg); |
| 90 | mtc.stop; |
| 91 | } |
| 92 | } |
| 93 | } |
| 94 | |
| 95 | friend function f_M3UA_connect(integer i) runs on RAW_M3UA_CT { |
| 96 | var Result res; |
| 97 | res := M3UA_CodecPort_CtrlFunct.f_IPL4_connect(M3UA[i], mp_stp_ip, mp_stp_m3ua_port, |
| 98 | mp_local_ip, mp_local_m3ua_port+i, -1, |
| 99 | {sctp:=valueof(ts_SCTP)}); |
| 100 | if (not ispresent(res.connId)) { |
| 101 | setverdict(fail, "Could not connect M3UA socket, check your configuration"); |
| 102 | mtc.stop; |
| 103 | } |
| 104 | g_m3ua_conn_id[i] := res.connId; |
| 105 | } |
| 106 | |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 107 | friend function f_M3UA_close(integer i) runs on RAW_M3UA_CT { |
| 108 | var Result res; |
| 109 | res := M3UA_CodecPort_CtrlFunct.f_IPL4_close(M3UA[i], g_m3ua_conn_id[i], {sctp:=valueof(ts_SCTP)}); |
| 110 | g_m3ua_conn_id[i] := 0; |
| 111 | } |
| 112 | |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 113 | friend function f_M3UA_listen(integer i) runs on RAW_M3UA_CT { |
| 114 | var Result res; |
| 115 | res := M3UA_CodecPort_CtrlFunct.f_IPL4_listen(M3UA[i], mp_local_ip, mp_local_m3ua_port+i, |
| 116 | {sctp:=valueof(ts_SCTP)}); |
| 117 | if (not ispresent(res.connId)) { |
| 118 | setverdict(fail, "Could not bind M3UA socket, check your configuration"); |
| 119 | mtc.stop; |
| 120 | } |
| 121 | } |
| 122 | |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 123 | friend function f_init_m3ua() runs on RAW_M3UA_CT { |
| 124 | var integer i; |
| 125 | |
| 126 | f_init_common(); |
| 127 | |
| 128 | activate(as_m3ua_sctp()); |
| 129 | |
| 130 | for (i := 0; i < NR_M3UA; i:=i+1) { |
| 131 | map(self:M3UA[i], system:M3UA_CODEC_PT); |
| 132 | f_M3UA_connect(i); |
| 133 | } |
| 134 | } |
| 135 | |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 136 | friend function f_clear_m3ua() runs on RAW_M3UA_CT { |
| 137 | var integer i; |
| 138 | |
| 139 | log("Clearing M3UA..."); |
| 140 | |
| 141 | for (i := 0; i < NR_M3UA; i:=i+1) { |
| 142 | f_M3UA_close(i); |
| 143 | } |
| 144 | /* Wait for recovery timer to trigger and shutdown all AS: */ |
| 145 | f_sleep(int2float(mp_recovery_timeout_msec)/1000.0 + 0.5); |
| 146 | setverdict(pass, "M3UA cleared"); |
| 147 | } |
| 148 | |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 149 | friend function f_init_m3ua_srv() runs on RAW_M3UA_CT { |
| 150 | var integer i; |
| 151 | var PortEvent sctp_evt; |
| 152 | |
| 153 | for (i := NR_M3UA; i < NR_M3UA+NR_M3UA_SRV; i:=i+1) { |
| 154 | map(self:M3UA[i], system:M3UA_CODEC_PT); |
| 155 | /* bind+ listen */ |
| 156 | f_M3UA_listen(i); |
| 157 | /* wait for accept() */ |
| 158 | M3UA[i].receive(tr_SctpConnOpened) -> value sctp_evt { |
| 159 | g_m3ua_conn_id[i] := sctp_evt.connOpened.connId; |
| 160 | } |
| 161 | } |
| 162 | } |
| 163 | |
| 164 | |
| 165 | /*********************************************************************** |
| 166 | * Test the STP in M3UA SG role (we are ASP) |
| 167 | ***********************************************************************/ |
| 168 | |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 169 | /* perform an outbound ASP-UP procedure */ |
| 170 | friend function f_M3UA_asp_up(integer idx, template (omit) OCT4 aspid := omit) runs on RAW_M3UA_CT { |
| 171 | f_M3UA_send(idx, ts_M3UA_ASPUP(aspid)); |
| 172 | f_M3UA_exp(idx, tr_M3UA_ASPUP_ACK); |
| 173 | } |
| 174 | |
| 175 | /* perform an outbound BEAT procedure */ |
| 176 | friend function f_M3UA_beat(integer idx, template (omit) octetstring hbd) runs on RAW_M3UA_CT { |
| 177 | if (istemplatekind(hbd, "omit")) { |
| 178 | f_M3UA_send(idx, ts_M3UA_BEAT(omit)); |
| 179 | f_M3UA_exp(idx, tr_M3UA_BEAT_ACK(omit)); |
| 180 | } else { |
| 181 | f_M3UA_send(idx, ts_M3UA_BEAT(ts_M3UA_hb_data(hbd))); |
| 182 | f_M3UA_exp(idx, tr_M3UA_BEAT_ACK(tr_M3UA_hb_data(hbd))); |
| 183 | } |
| 184 | } |
| 185 | |
| 186 | /* perform an outbound ASP-ACTIVATE procedure */ |
| 187 | friend function f_M3UA_asp_act(integer idx, template (omit) M3UA_Traffic_Mode_Type tmt := omit, |
| 188 | template (omit) OCT4 rctx := omit) runs on RAW_M3UA_CT { |
| 189 | f_M3UA_send(idx, ts_M3UA_ASPAC(tmt, rctx)); |
| 190 | f_M3UA_exp(idx, tr_M3UA_ASPAC_ACK(tmt, rctx)); |
| 191 | } |
| 192 | |
| 193 | /* perform outbound ASP-UP and ASP-ACT, optionally expect interemittent NOTIFY */ |
| 194 | friend function f_M3UA_asp_up_act(integer idx, template (omit) M3UA_Traffic_Mode_Type tmt := omit, |
| 195 | template (omit) OCT4 rctx := omit, |
| 196 | template (omit) OCT2 ntfy_after_up := c_M3UA_ST_I_AS_INACTIVE, |
| 197 | template (omit) OCT2 ntfy_after_act := c_M3UA_ST_I_AS_ACTIVE) |
| 198 | runs on RAW_M3UA_CT { |
| 199 | f_M3UA_asp_up(idx, omit); |
| 200 | if (not istemplatekind(ntfy_after_up, "omit")) { |
| 201 | f_M3UA_exp(idx, tr_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, ntfy_after_up, *)); |
| 202 | } |
| 203 | f_M3UA_asp_act(idx, tmt, rctx); |
| 204 | if (not istemplatekind(ntfy_after_act, "omit")) { |
| 205 | f_M3UA_exp(idx, tr_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, ntfy_after_act, *)); |
| 206 | } |
| 207 | } |
| 208 | |
| 209 | |
| 210 | /* Test the ASP-UP procedure */ |
| 211 | testcase TC_connect_asp_up() runs on RAW_M3UA_CT { |
| 212 | f_init_m3ua(); |
| 213 | f_M3UA_asp_up(0); |
| 214 | f_M3UA_exp(0, tr_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, c_M3UA_ST_I_AS_INACTIVE, *)); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 215 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | /* Test the heartbeat procedure without optional heartbeat data payload */ |
| 219 | testcase TC_beat() runs on RAW_M3UA_CT { |
| 220 | f_init_m3ua(); |
| 221 | f_M3UA_asp_up(0); |
| 222 | f_M3UA_exp(0, tr_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, c_M3UA_ST_I_AS_INACTIVE, *)); |
| 223 | f_M3UA_beat(0, omit); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 224 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | /* Test the heartbeat procedure with optional heartbeat data payload */ |
| 228 | testcase TC_beat_payload() runs on RAW_M3UA_CT { |
| 229 | f_init_m3ua(); |
| 230 | f_M3UA_asp_up(0); |
| 231 | f_M3UA_exp(0, tr_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, c_M3UA_ST_I_AS_INACTIVE, *)); |
| 232 | f_M3UA_beat(0, 'a1a2a3a4a5'O); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 233 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | /* Test the ASP-ACTIVATE procedure (without traffic-mode or routing ctx) */ |
| 237 | testcase TC_asp_act() runs on RAW_M3UA_CT { |
| 238 | f_init_m3ua(); |
| 239 | f_M3UA_asp_up_act(0); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 240 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | /* Test the ASP-ACTIVATE procedure with traffic-mode override */ |
| 244 | testcase TC_asp_act_override() runs on RAW_M3UA_CT { |
| 245 | f_init_m3ua(); |
| 246 | f_M3UA_asp_up_act(0, c_M3UA_TMT_override, omit); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 247 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | /* Test the ASP-ACTIVATE procedure with traffic-mode override */ |
| 251 | testcase TC_asp_act_loadshare() runs on RAW_M3UA_CT { |
| 252 | f_init_m3ua(); |
| 253 | f_M3UA_asp_up_act(0, c_M3UA_TMT_loadshare, omit); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 254 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 255 | } |
| 256 | |
| 257 | /* Test the ASP-ACTIVATE procedure with traffic-mode broadcast */ |
| 258 | testcase TC_asp_act_broadcast() runs on RAW_M3UA_CT { |
| 259 | f_init_m3ua(); |
| 260 | f_M3UA_asp_up_act(0, c_M3UA_TMT_broadcast, omit); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 261 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 262 | } |
| 263 | |
| 264 | /* Test if traffic is routed from idx_tx/pc_tx to idx_rx/pc_rx */ |
| 265 | private function f_test_traffic(integer idx_tx, template (omit) OCT4 rctx_sender, OCT4 pc_tx, |
| 266 | integer idx_rx, template (omit) OCT4 rctx_receiver, OCT4 pc_rx, |
| 267 | OCT1 si := '23'O, OCT1 ni := '00'O, OCT1 mp := '00'O, OCT1 sls := '00'O) |
| 268 | runs on RAW_M3UA_CT { |
| 269 | var octetstring data := f_rnd_octstring(f_rnd_int(100)); |
| 270 | f_M3UA_send(idx_tx, ts_M3UA_DATA(rctx_sender, |
| 271 | ts_M3UA_protocol_data(pc_tx, pc_rx, si, ni, mp, sls, data)), 1); |
| 272 | f_M3UA_exp(idx_rx, tr_M3UA_DATA(rctx_receiver, |
| 273 | tr_M3UA_protocol_data(pc_tx, pc_rx, si, ni, mp, sls, data))); |
| 274 | } |
| 275 | |
| 276 | |
| 277 | /* test "traffic-mode override" behavior */ |
| 278 | testcase TC_tmt_override() runs on RAW_M3UA_CT { |
| 279 | var OCT4 rctx_sender := int2oct(1023, 4); |
| 280 | var OCT4 pc_sender := int2oct(23, 4); |
| 281 | var OCT4 rctx_receiver := int2oct(1042, 4); |
| 282 | var OCT4 pc_receiver := int2oct(42, 4); |
| 283 | |
| 284 | f_init_m3ua(); |
| 285 | |
| 286 | /* bring up the 'sender' side (single ASP in AS) */ |
| 287 | f_M3UA_asp_up_act(0, omit, omit); |
| 288 | |
| 289 | /* activate the first 'receiver' side ASP */ |
| 290 | f_M3UA_asp_up_act(1, c_M3UA_TMT_override, rctx_receiver); |
| 291 | |
| 292 | /* verify traffic is routed from sender to [sole] receiver */ |
| 293 | f_test_traffic(0, rctx_sender, pc_sender, 1, rctx_receiver, pc_receiver); |
| 294 | |
| 295 | /* activate the second 'receiver' side ASP (no NOTIFY as AS state doesn't change) */ |
| 296 | f_M3UA_asp_up_act(2, c_M3UA_TMT_override, rctx_receiver, omit, omit); |
| 297 | |
| 298 | /* we expect a NOTIFY to the *other* ASP Other/Alternat-ASP-Active */ |
| 299 | f_M3UA_exp(1, tr_M3UA_NOTIFY(c_M3UA_ST_T_OTHER, c_M3UA_ST_I_ALTERNATE_ASP, *)); |
| 300 | |
| 301 | /* verify traffic is routed from sender to new receiver */ |
| 302 | f_test_traffic(0, rctx_sender, pc_sender, 2, rctx_receiver, pc_receiver); |
| 303 | |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 304 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | private altstep as_count_rx(integer idx, template (present) PDU_M3UA exp, inout integer counter) |
| 308 | runs on RAW_M3UA_CT { |
| 309 | [] M3UA[idx].receive(t_M3UA_RecvFrom(exp)) { |
| 310 | counter := counter + 1; |
| 311 | } |
| 312 | } |
| 313 | |
| 314 | /* test "traffic-mode load-share" behavior */ |
| 315 | testcase TC_tmt_loadshare() runs on RAW_M3UA_CT { |
| 316 | var OCT4 rctx_sender := int2oct(1023, 4); |
| 317 | var OCT4 pc_sender := int2oct(23, 4); |
| 318 | var OCT4 rctx_receiver := int2oct(1042, 4); |
| 319 | var OCT4 pc_receiver := int2oct(42, 4); |
| 320 | var integer i; |
| 321 | |
| 322 | f_init_m3ua(); |
| 323 | |
| 324 | /* FIXME: configure the STP via VTY to set traffic-mode */ |
| 325 | |
| 326 | /* bring up the 'sender' side (single ASP in AS) */ |
| 327 | f_M3UA_asp_up_act(0, omit, rctx_sender); |
| 328 | |
| 329 | /* activate the first 'receiver' side ASP */ |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 330 | f_M3UA_asp_up_act(1, c_M3UA_TMT_loadshare, omit); // TODO: rctx |
| 331 | |
| 332 | /* verify traffic is routed from sender to [sole] receiver */ |
| 333 | for (i := 0; i < 10; i := i+1) { |
| 334 | f_test_traffic(0, rctx_sender, pc_sender, 1, rctx_receiver, pc_receiver); |
| 335 | } |
| 336 | |
| 337 | /* activate the second 'receiver' side ASP (no NOTIFY) */ |
| 338 | f_M3UA_asp_up_act(2, c_M3UA_TMT_loadshare, omit, omit, omit); // TODO: rctx |
| 339 | |
| 340 | /* verify traffic is routed from sender to new receiver */ |
| 341 | const integer iter_per_asp := 5; |
| 342 | var integer num_rx[NR_M3UA] := { 0, 0, 0 }; |
| 343 | for (i := 0; i < 2*iter_per_asp; i := i+1) { |
| 344 | var octetstring data := f_rnd_octstring(f_rnd_int(100)); |
| 345 | var template (value) M3UA_Protocol_Data tx_pd; |
| 346 | var template (present) M3UA_Protocol_Data rx_pd; |
| 347 | tx_pd := ts_M3UA_protocol_data(pc_sender, pc_receiver, '23'O, '00'O, '00'O, '00'O, data); |
| 348 | rx_pd := tr_M3UA_protocol_data(pc_sender, pc_receiver, '23'O, '00'O, '00'O, '00'O, data); |
| 349 | f_M3UA_send(0, ts_M3UA_DATA(rctx_sender, tx_pd), 1); |
| 350 | alt { |
| 351 | [] as_count_rx(1, tr_M3UA_DATA(rctx_receiver, rx_pd), num_rx[1]) |
| 352 | [] as_count_rx(2, tr_M3UA_DATA(rctx_receiver, rx_pd), num_rx[2]) |
| 353 | } |
| 354 | } |
| 355 | /* FIXME: check for extraneous messages? */ |
| 356 | for (i := 1; i <= 2; i := i+1) { |
| 357 | if (num_rx[i] != iter_per_asp) { |
Harald Welte | b9f7bbb | 2019-10-29 09:07:11 +0100 | [diff] [blame] | 358 | setverdict(fail, "Received ", num_rx[i], " out of expected ", iter_per_asp, |
| 359 | "M3UA DATA messages at M3UA port ", i); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 360 | } |
| 361 | } |
| 362 | setverdict(pass); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 363 | |
| 364 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | /* test "traffic-mode broadcast" behavior */ |
| 368 | testcase TC_tmt_broadcast() runs on RAW_M3UA_CT { |
| 369 | var OCT4 rctx_sender := int2oct(1023, 4); |
| 370 | var OCT4 pc_sender := int2oct(23, 4); |
| 371 | var OCT4 rctx_receiver := int2oct(1042, 4); |
| 372 | var OCT4 pc_receiver := int2oct(42, 4); |
| 373 | var integer i; |
| 374 | |
| 375 | f_init_m3ua(); |
| 376 | |
| 377 | /* FIXME: configure the STP via VTY to set traffic-mode */ |
| 378 | |
| 379 | /* bring up the 'sender' side (single ASP in AS) */ |
| 380 | f_M3UA_asp_up_act(0, omit, omit); // TODO: rctx |
| 381 | |
| 382 | /* activate the first 'receiver' side ASP */ |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 383 | f_M3UA_asp_up_act(1, c_M3UA_TMT_broadcast, omit); // TODO: rctx |
| 384 | |
| 385 | /* verify traffic is routed from sender to [sole] receiver */ |
| 386 | for (i := 0; i < 10; i := i+1) { |
| 387 | f_test_traffic(0, rctx_sender, pc_sender, 1, rctx_receiver, pc_receiver); |
| 388 | } |
| 389 | |
| 390 | /* activate the second 'receiver' side ASP */ |
| 391 | f_M3UA_asp_up_act(2, c_M3UA_TMT_broadcast, omit, omit, omit); // TODO: rctx |
| 392 | |
| 393 | /* verify traffic is routed from sender to new receiver */ |
| 394 | for (i := 0; i < 10; i := i+1) { |
| 395 | var octetstring data := f_rnd_octstring(f_rnd_int(100)); |
| 396 | var template (value) M3UA_Protocol_Data tx_pd; |
| 397 | var template (present) M3UA_Protocol_Data rx_pd; |
| 398 | tx_pd := ts_M3UA_protocol_data(pc_sender, pc_receiver, '23'O, '00'O, '00'O, '00'O, data); |
| 399 | rx_pd := tr_M3UA_protocol_data(pc_sender, pc_receiver, '23'O, '00'O, '00'O, '00'O, data); |
| 400 | f_M3UA_send(0, ts_M3UA_DATA(rctx_sender, tx_pd), 1); |
| 401 | /* each message must be received both on 1 and 2 */ |
| 402 | f_M3UA_exp(1, tr_M3UA_DATA(rctx_receiver, rx_pd)); |
| 403 | f_M3UA_exp(2, tr_M3UA_DATA(rctx_receiver, rx_pd)); |
| 404 | } |
| 405 | setverdict(pass); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 406 | |
| 407 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 408 | } |
| 409 | |
| 410 | private function f_M3UA_rkm_register(OCT4 id, OCT3 dpc, OCT4 rctx, |
| 411 | template (present) OCT4 exp_status := c_M3UA_REGSTS_SUCCESS) |
| 412 | runs on RAW_M3UA_CT |
| 413 | { |
| 414 | f_M3UA_send(0, ts_M3UA_REG_REQ({ts_M3UA_rkey(id:=id, dpc:=dpc, rctx:=rctx)})); |
| 415 | f_M3UA_exp(0, tr_M3UA_REG_RSP({tr_M3UA_reg_res(id:=id, status:=exp_status, rctx:=rctx)})); |
| 416 | } |
| 417 | |
| 418 | /* Send RKM registration; expect -EPERM as RCTX doesn't match config and dynamic not permitted */ |
| 419 | testcase TC_rkm_reg_static_notpermitted() runs on RAW_M3UA_CT { |
| 420 | f_init_m3ua(); |
| 421 | |
| 422 | f_M3UA_send(0, ts_M3UA_REG_REQ({ts_M3UA_rkey(id:='00000099'O, dpc:='aabbcc'O)})); |
| 423 | f_M3UA_exp(0, tr_M3UA_REG_RSP({tr_M3UA_reg_res(id:='00000099'O, status:=c_M3UA_REGSTS_ERR_EPERM, |
| 424 | rctx:=?)})); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 425 | |
| 426 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 427 | } |
| 428 | |
| 429 | /* Send RKM registration; expect OK as RCTX does match config */ |
| 430 | testcase TC_rkm_reg_static_permitted() runs on RAW_M3UA_CT { |
| 431 | var OCT3 dpc := int2oct(23, 3); // must match config |
| 432 | var OCT4 rctx := int2oct(1023, 4); // must match config |
| 433 | |
| 434 | f_init_m3ua(); |
| 435 | |
| 436 | f_M3UA_send(0, ts_M3UA_REG_REQ({ts_M3UA_rkey(id:='10000099'O, dpc:=dpc, rctx:=rctx)})); |
| 437 | f_M3UA_exp(0, tr_M3UA_REG_RSP({tr_M3UA_reg_res(id:='10000099'O, status:=c_M3UA_REGSTS_SUCCESS, |
| 438 | rctx:=rctx)})); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 439 | |
| 440 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 441 | } |
| 442 | |
| 443 | /* Send RKM registration; expect OK as dynamic not permitted */ |
| 444 | testcase TC_rkm_reg_dynamic_permitted() runs on RAW_M3UA_CT { |
| 445 | f_init_common(); |
| 446 | f_vty_config2(VTY, {"cs7 instance 0"}, "xua rkm routing-key-allocation dynamic-permitted"); |
| 447 | f_init_m3ua(); |
| 448 | |
| 449 | f_M3UA_send(0, ts_M3UA_REG_REQ({ts_M3UA_rkey(id:='20000099'O, dpc:='aabbcc'O)})); |
| 450 | f_M3UA_exp(0, tr_M3UA_REG_RSP({tr_M3UA_reg_res(id:='20000099'O, status:=c_M3UA_REGSTS_SUCCESS, |
| 451 | rctx:=?)})); |
| 452 | |
| 453 | f_vty_config2(VTY, {"cs7 instance 0"}, "xua rkm routing-key-allocation static-only"); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 454 | |
| 455 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | /* try to de-register a routing key that was never registered -> error */ |
| 459 | testcase TC_rkm_unreg_never_registered() runs on RAW_M3UA_CT { |
| 460 | f_init_m3ua(); |
| 461 | f_M3UA_send(0, ts_M3UA_DEREG_REQ(ts_M3UA_routing_ctx(int2oct(1023,4)))); |
| 462 | f_M3UA_exp(0, tr_M3UA_DEREG_RSP({tr_M3UA_dereg_res(?,c_m3UA_DEREGSTS_ERR_NOT_REG)})); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 463 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 464 | } |
| 465 | |
| 466 | /* try to de-register a routing key that is invalid (non-existant) -> error */ |
| 467 | testcase TC_rkm_unreg_invalid() runs on RAW_M3UA_CT { |
| 468 | f_init_m3ua(); |
| 469 | f_M3UA_send(0, ts_M3UA_DEREG_REQ(ts_M3UA_routing_ctx(int2oct(1234,4)))); |
| 470 | f_M3UA_exp(0, tr_M3UA_DEREG_RSP({tr_M3UA_dereg_res(?,c_m3UA_DEREGSTS_ERR_INVAL_RCTX)})); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 471 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 472 | } |
| 473 | |
| 474 | /* try to de-register a routing key that was registered -> OK*/ |
| 475 | testcase TC_rkm_unreg_registered() runs on RAW_M3UA_CT { |
| 476 | f_init_m3ua(); |
| 477 | f_M3UA_send(0, ts_M3UA_DEREG_REQ(ts_M3UA_routing_ctx(int2oct(1023,4)))); |
| 478 | f_M3UA_exp(0, tr_M3UA_DEREG_RSP({tr_M3UA_dereg_res(?,c_m3UA_DEREGSTS_SUCCESS)})); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 479 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 480 | } |
| 481 | |
| 482 | /* try to de-register a routing key for an active ASP -> ERROR */ |
| 483 | testcase TC_rkm_unreg_active() runs on RAW_M3UA_CT { |
| 484 | var OCT3 dpc := int2oct(23, 3); // must match config |
| 485 | var OCT4 rctx := int2oct(1023, 4); // must match config |
| 486 | |
| 487 | f_init_m3ua(); |
| 488 | |
| 489 | /* first register the routing key */ |
| 490 | f_M3UA_rkm_register(id:='30000099'O, dpc:=dpc, rctx:=rctx); |
| 491 | |
| 492 | /* then activate the ASP */ |
| 493 | f_M3UA_asp_up_act(0); |
| 494 | |
| 495 | /* then try to de-regsiter */ |
| 496 | f_M3UA_send(0, ts_M3UA_DEREG_REQ(ts_M3UA_routing_ctx(rctx))); |
| 497 | f_M3UA_exp(0, tr_M3UA_DEREG_RSP({tr_M3UA_dereg_res(?,c_m3UA_DEREGSTS_ERR_ASP_ACTIVE)})); |
| 498 | /* FIXME: we now may have changed the state on the STP side! */ |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 499 | |
| 500 | f_clear_m3ua(); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 501 | } |
| 502 | |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 503 | /*********************************************************************** |
| 504 | * Test the STP in M3UA ASP role (we are SG) |
| 505 | ***********************************************************************/ |
| 506 | |
| 507 | /* expect/perform an inbound ASP-UP procedure */ |
| 508 | friend function f_M3UA_CLNT_asp_up(integer idx, template OCT4 aspid := omit) runs on RAW_M3UA_CT { |
| 509 | f_M3UA_exp(idx, tr_M3UA_ASPUP(aspid)); |
| 510 | f_M3UA_send(idx, ts_M3UA_ASPUP_ACK); |
| 511 | } |
| 512 | |
| 513 | /* expect/perform an inbound ASP-ACTIVATE procedure */ |
| 514 | friend function f_M3UA_CLNT_asp_act(integer idx, template M3UA_Traffic_Mode_Type tmt := omit, |
| 515 | template (omit) OCT4 rctx := omit) runs on RAW_M3UA_CT { |
| 516 | f_M3UA_exp(idx, tr_M3UA_ASPAC(tmt, rctx)); |
| 517 | f_M3UA_send(idx, ts_M3UA_ASPAC_ACK(tmt, rctx)); |
| 518 | } |
| 519 | |
| 520 | /* expect/perform inbound ASP-UP and ASP-ACT, optionally send interemittent NOTIFY */ |
| 521 | friend function f_M3UA_CLNT_asp_up_act(integer idx, template M3UA_Traffic_Mode_Type tmt := omit, |
| 522 | template OCT4 rctx := omit, |
| 523 | template (omit) OCT2 ntfy_after_up := c_M3UA_ST_I_AS_INACTIVE, |
| 524 | template (omit) OCT2 ntfy_after_act := c_M3UA_ST_I_AS_ACTIVE) |
| 525 | runs on RAW_M3UA_CT { |
| 526 | f_M3UA_CLNT_asp_up(idx, omit); |
| 527 | if (not istemplatekind(ntfy_after_up, "omit")) { |
| 528 | f_M3UA_send(idx, ts_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, ntfy_after_up, rctx)); |
| 529 | } |
| 530 | f_M3UA_CLNT_asp_act(idx, tmt, rctx); |
| 531 | if (not istemplatekind(ntfy_after_act, "omit")) { |
| 532 | f_M3UA_send(idx, ts_M3UA_NOTIFY(c_M3UA_ST_T_STATE_CHG, ntfy_after_act, rctx)); |
| 533 | } |
| 534 | } |
| 535 | |
| 536 | |
| 537 | /* Expect inbound connection from ASP/SCTP-client, followed by ASP-UP */ |
| 538 | testcase TC_clnt_connect_asp_up() runs on RAW_M3UA_CT { |
| 539 | f_init_m3ua(); |
| 540 | f_init_m3ua_srv(); |
| 541 | |
| 542 | f_M3UA_CLNT_asp_up(M3UA_SRV(0)); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 543 | |
| 544 | f_clear_m3ua(); |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 545 | } |
| 546 | |
| 547 | /* Expect inbound connection from ASP/SCTP-client, followed by ASP-UP + ASP-ACT */ |
| 548 | testcase TC_clnt_asp_act() runs on RAW_M3UA_CT { |
| 549 | f_init_m3ua(); |
| 550 | f_init_m3ua_srv(); |
| 551 | |
Harald Welte | dfbca11 | 2019-12-01 18:00:48 +0100 | [diff] [blame] | 552 | f_M3UA_CLNT_asp_up_act(M3UA_SRV(0), rctx := int2oct(1055, 4)); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 553 | |
| 554 | f_clear_m3ua(); |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 555 | } |
| 556 | |
Harald Welte | 53050cd | 2019-12-01 20:49:01 +0100 | [diff] [blame] | 557 | /* Expect inbound connection from ASP/SCTP-client, followed by ASP-UP + ASP-ACT */ |
| 558 | testcase TC_clnt_asp_act_tmt_loadshare() runs on RAW_M3UA_CT { |
| 559 | f_init_common(); |
| 560 | f_vty_config2(VTY, {"cs7 instance 0", "as as-client m3ua"}, "traffic-mode loadshare"); |
| 561 | f_init_m3ua(); |
| 562 | f_init_m3ua_srv(); |
| 563 | |
| 564 | f_M3UA_CLNT_asp_up_act(M3UA_SRV(0), tmt := c_M3UA_TMT_loadshare, rctx := int2oct(1055, 4)); |
| 565 | |
| 566 | f_clear_m3ua(); |
| 567 | } |
| 568 | |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 569 | /* Test traffic being routed through "server" side STP (M3UA SG), coming back in "client" |
| 570 | * side STP (M3UA ASP) */ |
| 571 | testcase TC_clnt_sg_to_asp() runs on RAW_M3UA_CT { |
| 572 | var OCT4 rctx_sender := int2oct(1023, 4); |
| 573 | var OCT4 pc_sender := int2oct(23, 4); |
| 574 | var OCT4 rctx_receiver := int2oct(1055, 4); |
| 575 | var OCT4 pc_receiver := int2oct(55, 4); |
| 576 | |
| 577 | f_init_m3ua(); |
| 578 | f_M3UA_asp_up_act(0); |
| 579 | |
| 580 | f_init_m3ua_srv(); |
Harald Welte | dfbca11 | 2019-12-01 18:00:48 +0100 | [diff] [blame] | 581 | f_M3UA_CLNT_asp_up_act(M3UA_SRV(0), rctx := int2oct(1055, 4)); |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 582 | |
| 583 | f_sleep(1.0); |
| 584 | |
| 585 | /* verify traffic is routed from sender to [sole] receiver */ |
| 586 | f_test_traffic(0, rctx_sender, pc_sender, M3UA_SRV(0), rctx_receiver, pc_receiver); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 587 | |
| 588 | f_clear_m3ua(); |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 589 | } |
| 590 | |
| 591 | /* Test traffic being routed through "client" side STP (M3UA ASP), coming back in "server" |
| 592 | * side STP (M3UA SG) */ |
| 593 | testcase TC_clnt_asp_to_sg() runs on RAW_M3UA_CT { |
| 594 | var OCT4 rctx_sender := int2oct(1055, 4); |
| 595 | var OCT4 pc_sender := int2oct(55, 4); |
| 596 | var OCT4 rctx_receiver := int2oct(1023, 4); |
| 597 | var OCT4 pc_receiver := int2oct(23, 4); |
| 598 | |
| 599 | f_init_m3ua(); |
| 600 | f_M3UA_asp_up_act(0); |
| 601 | |
| 602 | f_init_m3ua_srv(); |
Harald Welte | dfbca11 | 2019-12-01 18:00:48 +0100 | [diff] [blame] | 603 | f_M3UA_CLNT_asp_up_act(M3UA_SRV(0), rctx := int2oct(1055, 4)); |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 604 | |
| 605 | f_sleep(1.0); |
| 606 | |
| 607 | /* verify traffic is routed from sender to [sole] receiver */ |
| 608 | f_test_traffic(M3UA_SRV(0), rctx_sender, pc_sender, 0, rctx_receiver, pc_receiver); |
Pau Espin Pedrol | 05726dd | 2019-11-06 15:55:57 +0100 | [diff] [blame] | 609 | f_clear_m3ua(); |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 610 | } |
| 611 | |
| 612 | |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 613 | |
| 614 | control { |
| 615 | /* M3UA Tests */ |
| 616 | execute( TC_connect_asp_up() ); |
| 617 | execute( TC_beat() ); |
| 618 | execute( TC_beat_payload() ); |
| 619 | execute( TC_asp_act() ); |
| 620 | execute( TC_asp_act_override() ); |
| 621 | execute( TC_asp_act_loadshare() ); |
| 622 | execute( TC_asp_act_broadcast() ); |
| 623 | execute( TC_tmt_override() ); |
| 624 | execute( TC_tmt_loadshare() ); |
| 625 | execute( TC_tmt_broadcast() ); |
| 626 | |
| 627 | /* M3UA RKM tests */ |
| 628 | execute( TC_rkm_reg_static_notpermitted() ); |
| 629 | execute( TC_rkm_reg_static_permitted() ); |
| 630 | execute( TC_rkm_reg_dynamic_permitted() ); |
| 631 | execute( TC_rkm_unreg_never_registered() ); |
| 632 | execute( TC_rkm_unreg_invalid() ); |
| 633 | execute( TC_rkm_unreg_registered() ); |
| 634 | execute( TC_rkm_unreg_active() ); |
| 635 | /* TODO: test RKM with unsupported routing keys: NA, SI, OPC */ |
| 636 | /* TODO: register/unregister multiple routing contexts in one message; including mixed |
| 637 | success/failure situations */ |
Harald Welte | 829dac4 | 2019-11-05 16:55:30 +0100 | [diff] [blame] | 638 | |
| 639 | /* Test STP as SCTP client + M3UA ASP role */ |
| 640 | execute( TC_clnt_connect_asp_up() ); |
| 641 | execute( TC_clnt_asp_act() ); |
| 642 | execute( TC_clnt_sg_to_asp() ); |
| 643 | execute( TC_clnt_asp_to_sg() ); |
Harald Welte | 53050cd | 2019-12-01 20:49:01 +0100 | [diff] [blame] | 644 | |
| 645 | /* put this one last as it changes the stp side config */ |
| 646 | execute( TC_clnt_asp_act_tmt_loadshare() ); |
Harald Welte | 0db4413 | 2019-10-17 11:09:05 +0200 | [diff] [blame] | 647 | } |
| 648 | |
| 649 | |
| 650 | |
| 651 | } |