Merge branch 'maint'

4 files changed, 106 insertions, 65 deletions

diff --git a/lib/diameter/test/diameter_3xxx_SUITE.erl b/lib/diameter/test/diameter_3xxx_SUITE.erl
index 89c78d8b57..0ec0d5020f 100644
--- a/lib/diameter/test/diameter_3xxx_SUITE.erl
+++ b/lib/diameter/test/diameter_3xxx_SUITE.erl
@@ -40,7 +40,7 @@
          send_unknown_application/1,
          send_unknown_command/1,
          send_ok/1,
-         send_invalid_avp_bits/1,
+         send_invalid_hdr_bits/1,
          send_missing_avp/1,
          send_ignore_missing_avp/1,
          send_double_error/1,
@@ -136,7 +136,7 @@ tc() ->
     [send_unknown_application,
      send_unknown_command,
      send_ok,
-     send_invalid_avp_bits,
+     send_invalid_hdr_bits,
      send_missing_avp,
      send_ignore_missing_avp,
      send_double_error,
@@ -216,27 +216,26 @@ send_ok([_,_]) ->
 send_ok(Config) ->
     send_ok(?group(Config)).
 
-%% send_invalid_avp_bits/1
+%% send_invalid_hdr_bits/1
 %%
-%% Send a request with an incorrect length on the optional
-%% Origin-State-Id that a callback ignores.
+%% Send a request with an incorrect E-bit that a callback ignores.
 
 %% Callback answers.
-send_invalid_avp_bits([callback, _]) ->
+send_invalid_hdr_bits([callback, _]) ->
     #diameter_base_STA{'Result-Code' = 2001,  %% SUCCESS
                        'Failed-AVP' = [],
                        'AVP' = []}
         = call();
 
 %% diameter answers.
-send_invalid_avp_bits([_,_]) ->
-    #'diameter_base_answer-message'{'Result-Code' = 3009, %% INVALID_AVP_BITS
+send_invalid_hdr_bits([_,_]) ->
+    #'diameter_base_answer-message'{'Result-Code' = 3008, %% INVALID_HDR_BITS
                                     'Failed-AVP' = [],
                                     'AVP' = []}
         = call();
 
-send_invalid_avp_bits(Config) ->
-    send_invalid_avp_bits(?group(Config)).
+send_invalid_hdr_bits(Config) ->
+    send_invalid_hdr_bits(?group(Config)).
 
 %% send_missing_avp/1
 %%
@@ -282,8 +281,7 @@ send_ignore_missing_avp(Config) ->
 
 %% send_double_error/1
 %%
-%% Send a request with both an incorrect length on the optional
-%% Origin-State-Id and a missing AVP.
+%% Send a request with both an invalid E-bit and a missing AVP.
 
 %% Callback answers with STA.
 send_double_error([callback, _]) ->
@@ -294,8 +292,8 @@ send_double_error([callback, _]) ->
 
 %% diameter answers with answer-message.
 send_double_error([_,_]) ->
-    #'diameter_base_answer-message'{'Result-Code' = 3009, %% INVALID_AVP_BITS
-                                    'Failed-AVP' = [_],
+    #'diameter_base_answer-message'{'Result-Code' = 3008, %% INVALID_HDR_BITS
+                                    'Failed-AVP' = [],
                                     'AVP' = []}
         = call();
 
@@ -392,20 +390,16 @@ prepare(Pkt, Caps, T)
        T == send_5xxx ->
     sta(Pkt, Caps);
 
-prepare(Pkt0, Caps, send_invalid_avp_bits) ->
-    Req0 = sta(Pkt0, Caps),
-    %% Append an Origin-State-Id with an incorrect AVP Length in order
-    %% to force 3009.
-    Req = Req0#diameter_base_STR{'Origin-State-Id' = [7]},
-    #diameter_packet{bin = Bin}
+prepare(Pkt0, Caps, send_invalid_hdr_bits) ->
+    Req = sta(Pkt0, Caps),
+    %% Set the E-bit to force 3008.
+    #diameter_packet{bin = <<H:34, 0:1, T/bitstring>>}
         = Pkt
         = diameter_codec:encode(?DICT, Pkt0#diameter_packet{msg = Req}),
-    Offset = size(Bin) - 12 + 5,
-    <<H:Offset/binary, Len:24, T/binary>> = Bin,
-    Pkt#diameter_packet{bin = <<H/binary, (Len + 2):24, T/binary>>};
+    Pkt#diameter_packet{bin = <<H:34, 1:1, T/bitstring>>};
 
 prepare(Pkt0, Caps, send_double_error) ->
-    dehost(prepare(Pkt0, Caps, send_invalid_avp_bits));
+    dehost(prepare(Pkt0, Caps, send_invalid_hdr_bits));
 
 prepare(Pkt, Caps, T)
   when T == send_missing_avp;
@@ -480,9 +474,7 @@ request(send_3xxx, _Req, _Caps) ->
 request(send_5xxx, _Req, _Caps) ->
     {answer_message, 5999};
 
-request(send_invalid_avp_bits, Req, Caps) ->
-    #diameter_base_STR{'Origin-State-Id' = []}
-        = Req,
+request(send_invalid_hdr_bits, Req, Caps) ->
     %% Default errors field but a non-answer-message and only 3xxx
     %% errors detected means diameter sets neither Result-Code nor
     %% Failed-AVP.
diff --git a/lib/diameter/test/diameter_codec_SUITE_data/diameter_test_unknown.erl b/lib/diameter/test/diameter_codec_SUITE_data/diameter_test_unknown.erl
index bce3d78a37..49f2158b1a 100644
--- a/lib/diameter/test/diameter_codec_SUITE_data/diameter_test_unknown.erl
+++ b/lib/diameter/test/diameter_codec_SUITE_data/diameter_test_unknown.erl
@@ -71,6 +71,6 @@ dec('AR', #diameter_packet
 dec('BR', #diameter_packet
            {msg = #recv_BR{'Origin-Host'  = ?HOST,
                            'Origin-Realm' = ?REALM},
-            errors = [{5008, ?NOT_MANDATORY_YYY},
-                      {5001, ?MANDATORY_XXX}]}) ->
+            errors = [{5001, ?MANDATORY_XXX},
+                      {5008, ?NOT_MANDATORY_YYY}]}) ->
     ok.
diff --git a/lib/diameter/test/diameter_codec_test.erl b/lib/diameter/test/diameter_codec_test.erl
index 0baac59c1a..24d4c7665e 100644
--- a/lib/diameter/test/diameter_codec_test.erl
+++ b/lib/diameter/test/diameter_codec_test.erl
@@ -265,7 +265,7 @@ arity(M, Name, AvpName, Rec) ->
 %% enum/3
 
 enum(M, Name, {_,E}) ->
-    B = <<E:32/integer>>,
+    B = <<E:32>>,
     B = M:avp(encode, E, Name),
     E = M:avp(decode, B, Name).
 
@@ -322,15 +322,15 @@ values('Unsigned64') ->
 values('Float32') ->
     E = (1 bsl  8) - 2,
     F = (1 bsl 23) - 1,
-    <<Mx:32/float>> = <<0:1/integer, E:8/integer, F:23/integer>>,
-    <<Mn:32/float>> = <<1:1/integer, E:8/integer, F:23/integer>>,
+    <<Mx:32/float>> = <<0:1, E:8, F:23>>,
+    <<Mn:32/float>> = <<1:1, E:8, F:23>>,
     {[0.0, infinity, '-infinity', Mx, Mn], [0]};
 
 values('Float64') ->
     E = (1 bsl 11) - 2,
     F = (1 bsl 52) - 1,
-    <<Mx:64/float>> = <<0:1/integer, E:11/integer, F:52/integer>>,
-    <<Mn:64/float>> = <<1:1/integer, E:11/integer, F:52/integer>>,
+    <<Mx:64/float>> = <<0:1, E:11, F:52>>,
+    <<Mn:64/float>> = <<1:1, E:11, F:52>>,
     {[0.0, infinity, '-infinity', Mx, Mn], [0]};
 
 values('Address') ->
diff --git a/lib/diameter/test/diameter_traffic_SUITE.erl b/lib/diameter/test/diameter_traffic_SUITE.erl
index 2684ab8fe4..38bdf55af8 100644
--- a/lib/diameter/test/diameter_traffic_SUITE.erl
+++ b/lib/diameter/test/diameter_traffic_SUITE.erl
@@ -49,9 +49,12 @@
          send_unsupported_app/1,
          send_error_bit/1,
          send_unsupported_version/1,
-         send_invalid_avp_bits/1,
+         send_long_avp_length/1,
+         send_short_avp_length/1,
+         send_zero_avp_length/1,
          send_invalid_avp_length/1,
          send_invalid_reject/1,
+         send_unrecognized_mandatory/1,
          send_long/1,
          send_nopeer/1,
          send_noapp/1,
@@ -268,9 +271,12 @@ tc() ->
      send_unsupported_app,
      send_error_bit,
      send_unsupported_version,
-     send_invalid_avp_bits,
+     send_long_avp_length,
+     send_short_avp_length,
+     send_zero_avp_length,
      send_invalid_avp_length,
      send_invalid_reject,
+     send_unrecognized_mandatory,
      send_long,
      send_nopeer,
      send_noapp,
@@ -416,13 +422,14 @@ send_protocol_error(Config) ->
     ?answer_message(?TOO_BUSY)
         = call(Config, Req).
 
-%% Send an ASR with an arbitrary AVP and expect success and the same
-%% AVP in the reply.
+%% Send an ASR with an arbitrary non-mandatory AVP and expect success
+%% and the same AVP in the reply.
 send_arbitrary(Config) ->
-    Req = ['ASR', {'AVP', [#diameter_avp{name = 'Class', value = "XXX"}]}],
+    Req = ['ASR', {'AVP', [#diameter_avp{name = 'Product-Name',
+                                         value = "XXX"}]}],
     ['ASA', _SessionId, {'Result-Code', ?SUCCESS} | Avps]
         = call(Config, Req),
-    {'AVP', [#diameter_avp{name = 'Class',
+    {'AVP', [#diameter_avp{name = 'Product-Name',
                            value = "XXX"}]}
         = lists:last(Avps).
 
@@ -481,19 +488,33 @@ send_unsupported_version(Config) ->
     ['STA', _SessionId, {'Result-Code', ?UNSUPPORTED_VERSION} | _]
         = call(Config, Req).
 
-%% Send a request containing an incorrect AVP length.
-send_invalid_avp_bits(Config) ->
-    Req = ['STR', {'Termination-Cause', ?LOGOUT}],
+%% Send a request containing an AVP length > data size.
+send_long_avp_length(Config) ->
+    send_invalid_avp_length(Config).
 
-    ?answer_message(?INVALID_AVP_BITS)
-        = call(Config, Req).
+%% Send a request containing an AVP length < data size.
+send_short_avp_length(Config) ->
+    send_invalid_avp_length(Config).
+
+%% Send a request containing an AVP whose advertised length is < 8.
+send_zero_avp_length(Config) ->
+    send_invalid_avp_length(Config).
 
 %% Send a request containing an AVP length that doesn't match the
 %% AVP's type.
 send_invalid_avp_length(Config) ->
     Req = ['STR', {'Termination-Cause', ?LOGOUT}],
 
-    ['STA', _SessionId, {'Result-Code', ?INVALID_AVP_LENGTH} | _]
+    ['STA', _SessionId,
+            {'Result-Code', ?INVALID_AVP_LENGTH},
+            _OriginHost,
+            _OriginRealm,
+            _UserName,
+            _Class,
+            _ErrorMessage,
+            _ErrorReportingHost,
+            {'Failed-AVP', [#'diameter_base_Failed-AVP'{'AVP' = [_]}]}
+          | _]
         = call(Config, Req).
 
 %% Send a request containing 5xxx errors that the server rejects with
@@ -504,6 +525,14 @@ send_invalid_reject(Config) ->
     ?answer_message(?TOO_BUSY)
         = call(Config, Req).
 
+%% Send an STR containing a known AVP, but one that's not allowed and
+%% sets the M-bit.
+send_unrecognized_mandatory(Config) ->
+    Req = ['STR', {'Termination-Cause', ?LOGOUT}],
+
+    ['STA', _SessionId, {'Result-Code', ?AVP_UNSUPPORTED} | _]
+        = call(Config, Req).
+
 %% Send something long that will be fragmented by TCP.
 send_long(Config) ->
     Req = ['STR', {'Termination-Cause', ?LOGOUT},
@@ -804,45 +833,63 @@ log(#diameter_packet{bin = Bin} = P, T)
 
 %% prepare/4
 
-prepare(Pkt, Caps, send_invalid_avp_bits, #group{client_dict0 = Dict0}
-                                          = Group) ->
+prepare(Pkt, Caps, N, #group{client_dict0 = Dict0} = Group)
+  when N == send_long_avp_length;
+       N == send_short_avp_length;
+       N == send_zero_avp_length ->
     Req = prepare(Pkt, Caps, Group),
-    %% Last AVP in our STR is Termination-Cause of type Unsigned32:
-    %% set its length improperly.
+    %% Second last AVP in our STR is Auth-Application-Id of type
+    %% Unsigned32: set AVP Length to a value other than 12 and place
+    %% it last in the message (so as not to mess with Termination-Cause).
     #diameter_packet{header = #diameter_header{length = L},
                      bin = B}
         = E
         = diameter_codec:encode(Dict0, Pkt#diameter_packet{msg = Req}),
-    Offset = L - 7,  %% to AVP Length
-    <<H:Offset/binary, 12:24/integer, T:4/binary>> = B,
-    E#diameter_packet{bin = <<H/binary, 13:24/integer, T/binary>>};
+    Offset = L - 24,  %% to Auth-Application-Id
+    <<H:Offset/binary,
+      Hdr:5/binary, 12:24, Data:4/binary,
+      T:12/binary>>
+        = B,
+    AL = case N of
+             send_long_avp_length  -> 13;
+             send_short_avp_length -> 11;
+             send_zero_avp_length  -> 0
+         end,
+    E#diameter_packet{bin = <<H/binary,
+                              T/binary,
+                              Hdr/binary, AL:24, Data/binary>>};
 
 prepare(Pkt, Caps, N, #group{client_dict0 = Dict0} = Group)
   when N == send_invalid_avp_length;
        N == send_invalid_reject ->
     Req = prepare(Pkt, Caps, Group),
     %% Second last AVP in our STR is Auth-Application-Id of type
-    %% Unsigned32: Send a value of length 8.
+    %% Unsigned32: send data of length 8.
     #diameter_packet{header = #diameter_header{length = L},
                      bin = B0}
         = E
         = diameter_codec:encode(Dict0, Pkt#diameter_packet{msg = Req}),
     Offset = L - 7 - 12,  %% to AVP Length
-    <<H0:Offset/binary, 12:24/integer, T:16/binary>> = B0,
-    <<V, L:24/integer, H/binary>> = H0,  %% assert
-    E#diameter_packet{bin = <<V,
-                              (L+4):24/integer,
-                              H/binary,
-                              16:24/integer,
-                              0:32/integer,
-                              T/binary>>};
+    <<H0:Offset/binary, 12:24, T:16/binary>> = B0,
+    <<V, L:24, H/binary>> = H0,  %% assert
+    E#diameter_packet{bin = <<V, (L+4):24, H/binary, 16:24, 0:32, T/binary>>};
+
+prepare(Pkt, Caps, send_unrecognized_mandatory, #group{client_dict0 = Dict0}
+                                                = Group) ->
+    Req = prepare(Pkt, Caps, Group),
+    #diameter_packet{bin = <<V, Len:24, T/binary>>}
+        = E
+        = diameter_codec:encode(Dict0, Pkt#diameter_packet{msg = Req}),
+    {Code, Flags, undefined} = Dict0:avp_header('Proxy-State'),
+    Avp = <<Code:32, Flags, 8:24>>,
+    E#diameter_packet{bin = <<V, (Len+8):24, T/binary, Avp/binary>>};
 
 prepare(Pkt, Caps, send_unsupported, #group{client_dict0 = Dict0} = Group) ->
     Req = prepare(Pkt, Caps, Group),
     #diameter_packet{bin = <<H:5/binary, _CmdCode:3/binary, T/binary>>}
         = E
         = diameter_codec:encode(Dict0, Pkt#diameter_packet{msg = Req}),
-    E#diameter_packet{bin = <<H/binary, 42:24/integer, T/binary>>};
+    E#diameter_packet{bin = <<H/binary, 42:24, T/binary>>};
 
 prepare(Pkt, Caps, send_unsupported_app, #group{client_dict0 = Dict0}
                                          = Group) ->
@@ -850,7 +897,7 @@ prepare(Pkt, Caps, send_unsupported_app, #group{client_dict0 = Dict0}
     #diameter_packet{bin = <<H:8/binary, _ApplId:4/binary, T/binary>>}
         = E
         = diameter_codec:encode(Dict0, Pkt#diameter_packet{msg = Req}),
-    E#diameter_packet{bin = <<H/binary, ?BAD_APP:32/integer, T/binary>>};
+    E#diameter_packet{bin = <<H/binary, ?BAD_APP:32, T/binary>>};
 
 prepare(Pkt, Caps, send_error_bit, Group) ->
     #diameter_packet{header = Hdr} = Pkt,
@@ -944,7 +991,9 @@ answer(Pkt, Req, _Peer, Name, #group{client_dict0 = Dict0}) ->
     [Dict:rec2msg(R) | Vs].
 
 answer(Rec, [_|_], N)
-  when N == send_invalid_avp_bits;
+  when N == send_long_avp_length;
+       N == send_short_avp_length;
+       N == send_zero_avp_length;
        N == send_invalid_avp_length;
        N == send_invalid_reject ->
     Rec;