2 files changed, 44 insertions, 40 deletions

diff --git a/lib/diameter/src/base/diameter_service.erl b/lib/diameter/src/base/diameter_service.erl
index 3ae6ed755f..7adcf1c265 100644
--- a/lib/diameter/src/base/diameter_service.erl
+++ b/lib/diameter/src/base/diameter_service.erl
@@ -1255,11 +1255,11 @@ send_request({TPid, Caps, App}, Msg, Opts, Caller, SvcName) ->
     #diameter_app{module = ModX}
         = App,
 
-    Pkt = make_packet(Msg),
+    Pkt = make_request_packet(Msg),
 
     case cb(ModX, prepare_request, [Pkt, SvcName, {TPid, Caps}]) of
         {send, P} ->
-            send_request(make_packet(P, Pkt),
+            send_request(make_request_packet(P, Pkt),
                          TPid,
                          Caps,
                          App,
@@ -1274,70 +1274,73 @@ send_request({TPid, Caps, App}, Msg, Opts, Caller, SvcName) ->
             ?ERROR({invalid_return, prepare_request, App, T})
     end.
 
-%% make_packet/1
+%% make_request_packet/1
 %%
 %% Turn an outgoing request as passed to call/4 into a diameter_packet
 %% record in preparation for a prepare_request callback.
 
-make_packet(Bin)
+make_request_packet(Bin)
   when is_binary(Bin) ->
     #diameter_packet{header = diameter_codec:decode_header(Bin),
                      bin = Bin};
 
-make_packet(#diameter_packet{msg = [#diameter_header{} = Hdr | Avps]} = Pkt) ->
-    Pkt#diameter_packet{msg = [make_header(Hdr) | Avps]};
+make_request_packet(#diameter_packet{msg = [#diameter_header{} = Hdr | Avps]}
+                    = Pkt) ->
+    Pkt#diameter_packet{msg = [make_request_header(Hdr) | Avps]};
 
-make_packet(#diameter_packet{header = Hdr} = Pkt) ->
-    Pkt#diameter_packet{header = make_header(Hdr)};
+make_request_packet(#diameter_packet{header = Hdr} = Pkt) ->
+    Pkt#diameter_packet{header = make_request_header(Hdr)};
 
-make_packet(Msg) ->
-    make_packet(#diameter_packet{msg = Msg}).
+make_request_packet(Msg) ->
+    make_request_packet(#diameter_packet{msg = Msg}).
 
-%% make_header/1
+%% make_request_header/1
 
-make_header(undefined) ->
+make_request_header(undefined) ->
     Seq = diameter_session:sequence(),
-    make_header(#diameter_header{end_to_end_id = Seq,
-                                 hop_by_hop_id = Seq});
+    make_request_header(#diameter_header{end_to_end_id = Seq,
+                                         hop_by_hop_id = Seq});
 
-make_header(#diameter_header{version = undefined} = Hdr) ->
-    make_header(Hdr#diameter_header{version = ?DIAMETER_VERSION});
+make_request_header(#diameter_header{version = undefined} = Hdr) ->
+    make_request_header(Hdr#diameter_header{version = ?DIAMETER_VERSION});
 
-make_header(#diameter_header{end_to_end_id = undefined} = H) ->
+make_request_header(#diameter_header{end_to_end_id = undefined} = H) ->
     Seq = diameter_session:sequence(),
-    make_header(H#diameter_header{end_to_end_id = Seq});
+    make_request_header(H#diameter_header{end_to_end_id = Seq});
 
-make_header(#diameter_header{hop_by_hop_id = undefined} = H) ->
+make_request_header(#diameter_header{hop_by_hop_id = undefined} = H) ->
     Seq = diameter_session:sequence(),
-    make_header(H#diameter_header{hop_by_hop_id = Seq});
+    make_request_header(H#diameter_header{hop_by_hop_id = Seq});
 
-make_header(#diameter_header{} = Hdr) ->
+make_request_header(#diameter_header{} = Hdr) ->
     Hdr;
 
-make_header(T) ->
+make_request_header(T) ->
     ?ERROR({invalid_header, T}).
 
-%% make_packet/2
+%% make_request_packet/2
 %%
 %% Reconstruct a diameter_packet from the return value of
 %% prepare_request or prepare_retransmit callback.
 
-make_packet(Bin, _)
+make_request_packet(Bin, _)
   when is_binary(Bin) ->
-    make_packet(Bin);
+    make_request_packet(Bin);
 
-make_packet(#diameter_packet{msg = [#diameter_header{} | _]} = Pkt, _) ->
+make_request_packet(#diameter_packet{msg = [#diameter_header{} | _]}
+                    = Pkt,
+                    _) ->
     Pkt;
 
 %% Returning a diameter_packet with no header from a prepare_request
 %% or prepare_retransmit callback retains the header passed into it.
 %% This is primarily so that the end to end and hop by hop identifiers
 %% are retained.
-make_packet(#diameter_packet{header = Hdr} = Pkt,
+make_request_packet(#diameter_packet{header = Hdr} = Pkt,
             #diameter_packet{header = Hdr0}) ->
     Pkt#diameter_packet{header = fold_record(Hdr0, Hdr)};
 
-make_packet(Msg, Pkt) ->
+make_request_packet(Msg, Pkt) ->
     Pkt#diameter_packet{msg = Msg}.
 
 %% fold_record/2
@@ -1529,7 +1532,7 @@ retransmit({TPid, Caps, #diameter_app{alias = Alias} = App},
 
     case cb(App, prepare_retransmit, [Pkt, SvcName, {TPid, Caps}]) of
         {send, P} ->
-            retransmit(make_packet(P, Pkt), TPid, Caps, Req, Timeout);
+            retransmit(make_request_packet(P, Pkt), TPid, Caps, Req, Timeout);
         {discard, Reason} ->
             ?THROW(Reason);
         discard ->
@@ -1942,7 +1945,7 @@ reply(Msg, Dict, TPid, #diameter_packet{errors = Es,
                        = ReqPkt)
   when [] == Es;
        is_record(hd(Msg), diameter_header) ->
-    Pkt = diameter_codec:encode(Dict, make_reply_packet(Msg, ReqPkt)),
+    Pkt = diameter_codec:encode(Dict, make_answer_packet(Msg, ReqPkt)),
     incr(send, Pkt, Dict, TPid),  %% count result codes in sent answers
     send(TPid, Pkt#diameter_packet{transport_data = TD});
 
@@ -1953,18 +1956,19 @@ reply(Msg, Dict, TPid, #diameter_packet{errors = [H|_] = Es} = Pkt) ->
           TPid,
           Pkt#diameter_packet{errors = []}).
 
-%% make_reply_packet/2
+%% make_answer_packet/2
 
 %% Binaries and header/avp lists are sent as-is.
-make_reply_packet(Bin, _)
+make_answer_packet(Bin, _)
   when is_binary(Bin) ->
     #diameter_packet{bin = Bin};
-make_reply_packet([#diameter_header{} | _] = Msg, _) ->
+make_answer_packet([#diameter_header{} | _] = Msg, _) ->
     #diameter_packet{msg = Msg};
 
 %% Otherwise a reply message clears the R and T flags and retains the
-%% P flag. The E flag will be set at encode.
-make_reply_packet(Msg, #diameter_packet{header = ReqHdr}) ->
+%% P flag. The E flag will be set at encode. 6.2 of 3588 requires the
+%% same P flag on an answer as on the request.
+make_answer_packet(Msg, #diameter_packet{header = ReqHdr}) ->
     Hdr = ReqHdr#diameter_header{version = ?DIAMETER_VERSION,
                                  is_request = false,
                                  is_error = undefined,
diff --git a/lib/diameter/src/base/diameter_watchdog.erl b/lib/diameter/src/base/diameter_watchdog.erl
index b7c1491f4b..6dc53d9f31 100644
--- a/lib/diameter/src/base/diameter_watchdog.erl
+++ b/lib/diameter/src/base/diameter_watchdog.erl
@@ -179,11 +179,11 @@ transition({close, TPid, _Reason}, #watchdog{transport = TPid}) ->
 %% state okay as the result of the Peer State Machine reaching the
 %% Open state.
 %%
-%% If we're an acceptor then we may be resuming a connection that went
-%% down in another acceptor process, in which case this is the
-%% transition below, from down into reopen. That is, it's not until
-%% we know the identity of the peer (ie. now) that we know that we're
-%% in state down rather than initial.
+%% If we're accepting then we may be resuming a connection that went
+%% down in another watchdog process, in which case this is the
+%% transition below, from down to reopen. That is, it's not until we
+%% know the identity of the peer (ie. now) that we know that we're in
+%% state down rather than initial.
 
 transition({open, TPid, Hosts, T} = Open,
            #watchdog{transport = TPid,