File 0654-megaco-replace-size-1-by-xxx_size-1.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 0654-megaco-replace-size-1-by-xxx_size-1.patch of Package erlang (Revision 0c80a4377fd7b2416091869002f3c6d9)

Currently displaying revision 0c80a4377fd7b2416091869002f3c6d9 , Show latest

From 02cbc39cc98c212988aa9354180fe28ff1e47dac Mon Sep 17 00:00:00 2001
From: Kiko Fernandez-Reyes <kiko@erlang.org>
Date: Thu, 2 Feb 2023 09:05:16 +0100
Subject: [PATCH] megaco: replace size/1 by xxx_size/1

The <c>size/1</c> BIF is not optimized by the JIT, and its use can
result in worse types for Dialyzer.

When one knows that the value being tested must be a tuple,
<c>tuple_size/1</c> should always be preferred.

When one knows that the value being tested must be a binary,
<c>byte_size/1</c> should be preferred. However, <c>byte_size/1</c> also
accepts a bitstring (rounding up size to a whole number of bytes), so
one must make sure that the call to <c>byte_size/</c> is preceded by a
call to <c>is_binary/1</c> to ensure that bitstrings are rejected. Note
that the compiler removes redundant calls to <c>is_binary/1</c>, so if
one is not sure whether previous code had made sure that the argument is
a binary, it does not harm to add an <c>is_binary/1</c> test immediately
before the call to <c>byte_size/1</c>.
---
 lib/megaco/src/engine/megaco_filter.erl       |  4 +--
 .../src/engine/megaco_messenger_misc.erl      |  2 +-
 lib/megaco/src/engine/megaco_trans_sender.erl | 30 +++++++++----------
 lib/megaco/src/flex/megaco_flex_scanner.erl   |  4 +--
 lib/megaco/src/tcp/megaco_tcp.erl             |  6 ++--
 lib/megaco/src/tcp/megaco_tcp_connection.erl  | 12 ++++----
 lib/megaco/src/udp/megaco_udp.erl             |  2 +-
 lib/megaco/src/udp/megaco_udp_server.erl      |  8 ++---
 8 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/lib/megaco/src/engine/megaco_filter.erl b/lib/megaco/src/engine/megaco_filter.erl
index 4bd3bd518b..79125ff252 100644
--- a/lib/megaco/src/engine/megaco_filter.erl
+++ b/lib/megaco/src/engine/megaco_filter.erl
@@ -300,10 +300,10 @@ do_filter_contents([H | T], E, ConnData, Contents) ->
             E2 = 
 		case E#event.label of
 		    [$s, $e, $n, $d, $ , $b, $y, $t, $e, $s | Tail] ->
-			L = lists:concat(["send ", size(Bin), " bytes", Tail]),
+			L = lists:concat(["send ", byte_size(Bin), " bytes", Tail]),
 			E#event{label = L};
 		    [$r, $e, $c, $e, $i, $v, $e, $ , $b, $y, $t, $e, $s | Tail] ->
-			L = lists:concat(["receive ", size(Bin), " bytes", Tail]),
+			L = lists:concat(["receive ", byte_size(Bin), " bytes", Tail]),
 			E#event{label = L};
 		    _ ->
 			E
diff --git a/lib/megaco/src/engine/megaco_messenger_misc.erl b/lib/megaco/src/engine/megaco_messenger_misc.erl
index 091f64e5b4..e1a9e501c6 100644
--- a/lib/megaco/src/engine/megaco_messenger_misc.erl
+++ b/lib/megaco/src/engine/megaco_messenger_misc.erl
@@ -217,7 +217,7 @@ encode_action_replies(#conn_data{protocol_version = V,
 		      [AR|ARs], Size, Acc) ->
     case (catch Mod:encode_action_reply(Conf, V, AR)) of
 	{ok, Bin} when is_binary(Bin) ->
-	    encode_action_replies(CD, ARs, Size + size(Bin), [Bin|Acc]);
+	    encode_action_replies(CD, ARs, Size + byte_size(Bin), [Bin|Acc]);
         {'EXIT', {undef, _}} ->
             throw({error, not_implemented});
 	{error, not_implemented} = Error1 ->
diff --git a/lib/megaco/src/engine/megaco_trans_sender.erl b/lib/megaco/src/engine/megaco_trans_sender.erl
index 4bb96e1cf4..459e1a582d 100644
--- a/lib/megaco/src/engine/megaco_trans_sender.erl
+++ b/lib/megaco/src/engine/megaco_trans_sender.erl
@@ -165,14 +165,14 @@ loop(#state{reqs = [], acks = [], timeout = Timeout} = S, _) ->
 	    _ = send_msg(S#state.conn_handle, [], [Serial]),
 	    loop(S, Timeout);
 
-	{send_req, Tid, Req} when size(Req) >= S#state.req_maxsize ->
+	{send_req, Tid, Req} when is_binary(Req), byte_size(Req) >= S#state.req_maxsize ->
 	    ?d("loop(empty) -> received (big) send_req request ~w", [Tid]),
 	    _ = send_msg(S#state.conn_handle, [{Tid, Req}], []),
 	    loop(S, Timeout);
 
-	{send_req, Tid, Req} ->
+	{send_req, Tid, Req} when is_binary(Req) ->
 	    ?d("loop(empty) -> received send_req request ~w", [Tid]),
-	    loop(S#state{req_sz = size(Req), reqs = [{Tid,Req}]}, Timeout);
+	    loop(S#state{req_sz = byte_size(Req), reqs = [{Tid,Req}]}, Timeout);
 
 	{send_reqs, Tids, Reqs} ->
 	    ?d("loop(empty) -> received send_reqs request: ~w", [Tids]),
@@ -381,7 +381,7 @@ loop(#state{reqs = Reqs, acks = Acks, timeout = Timeout} = S, _To) ->
 handle_send_req(Tid, Req, 
 		#state{conn_handle = CH, 
 		       req_maxsize = MaxSz, reqs = Reqs, acks = Acks} = S) 
-  when size(Req) >= MaxSz ->
+  when is_binary(Req), byte_size(Req) >= MaxSz ->
     ?d("handle_send_req -> request bigger then maxsize ~w", [MaxSz]),
     handle_send_result( send_msg(CH, Reqs, Acks) ),
     handle_send_result( send_msg(CH, [{Tid, Req}], []) ),
@@ -407,7 +407,7 @@ handle_send_req(Tid, Req,
 	     ),
 	    {S#state{req_sz = 0, reqs = [], acks = []}, true};
 
-	false when size(Req) + ReqSz >= MaxSz ->
+	false when is_binary(Req), byte_size(Req) + ReqSz >= MaxSz ->
 	    %% We finally passed the req-maxsize limit
 	    ?d("handle_send_req -> maxsize ~w passed", [MaxSz]),
 	    handle_send_result( 
@@ -415,10 +415,10 @@ handle_send_req(Tid, Req,
 	     ),
 	    {S#state{req_sz = 0, reqs = [], acks = []}, true};
 
-	false ->
+	false when is_binary(Req) ->
 	    %% Still not time to send
 	    ?d("handle_send_req -> nothing to be sent",[]),
-	    {S#state{req_sz = ReqSz + size(Req), reqs = [{Tid, Req}|Reqs]}, 
+	    {S#state{req_sz = ReqSz + byte_size(Req), reqs = [{Tid, Req}|Reqs]},
 	     false}
     end.
 	    
@@ -494,33 +494,33 @@ maybe_send_reqs(_CH, [], _Acks, Acc, AccSz, _MaxSz, Sent) ->
 	"~n   length(Acc): ~w", [Sent, AccSz, length(Acc)]),
     {Acc, AccSz, Sent};
 maybe_send_reqs(CH, [{Tid, Req}|Reqs], Acks, Acc, _AccSz, MaxSz, _Sent) 
-  when size(Req) >= MaxSz ->
+  when is_binary(Req), byte_size(Req) >= MaxSz ->
     %% The request was above the maxsize limit, so first send 
     %% what's in store and the the big request.
     ?d("maybe_send_reqs -> entry when request [~w] size (~w) > max size"
 	"~n   Acks:        ~w"
-	"~n   length(Acc): ~w", [Tid, size(Req), Acks, length(Acc)]),
+	"~n   length(Acc): ~w", [Tid, byte_size(Req), Acks, length(Acc)]),
     handle_send_result( send_msg(CH, Acc, Acks) ),
     handle_send_result( send_msg(CH, [{Tid, Req}], []) ),
     maybe_send_reqs(CH, Reqs, [], [], 0, MaxSz, true);
 maybe_send_reqs(CH, [{Tid, Req}|Reqs], Acks, Acc, AccSz, MaxSz, _Sent) 
-  when AccSz + size(Req) >= MaxSz ->
+  when is_binary(Req), AccSz + byte_size(Req) >= MaxSz ->
     %% We _did_ pass the maxsize limit with this request, so send 
     ?d("maybe_send_reqs -> entry when sum of requests (~w) > max size"
 	"~n   Tid:         ~w"
 	"~n   Acks:        ~w"
-	"~n   length(Acc): ~w", [Tid, size(Req) + AccSz, Acks, length(Acc)]),
+	"~n   length(Acc): ~w", [Tid, byte_size(Req) + AccSz, Acks, length(Acc)]),
     handle_send_result( send_msg(CH, [{Tid, Req}|Acc], Acks) ),
     maybe_send_reqs(CH, Reqs, [], [], 0, MaxSz, true);
-maybe_send_reqs(CH, [{Tid, Req}|Reqs], Acks, Acc, AccSz, MaxSz, Sent) ->
+maybe_send_reqs(CH, [{Tid, Req}|Reqs], Acks, Acc, AccSz, MaxSz, Sent) when is_binary(Req) ->
     ?d("maybe_send_reqs -> entry when"
 	"~n   Tid:         ~w"
 	"~n   size(Req):   ~w"
 	"~n   Acks:        ~w"
 	"~n   length(Acc): ~w"
-	"~n   AccSz:       ~w", [Tid, size(Req), Acks, length(Acc), AccSz]),
+	"~n   AccSz:       ~w", [Tid, byte_size(Req), Acks, length(Acc), AccSz]),
     NewAcc   = [{Tid,Req}|Acc], 
-    NewAccSz = AccSz + size(Req), 
+    NewAccSz = AccSz + byte_size(Req),
     maybe_send_reqs(CH, Reqs, Acks, NewAcc, NewAccSz, MaxSz, Sent).
 
     
@@ -548,7 +548,7 @@ send_reply(CH, Reply, MaxSz, _ReqSz, Reqs, Acks) ->
 	"~n   length(Reqs): ~w"
 	"~n   length(Acks): ~w", [length(Reqs), length(Acks)]),
     case megaco_config:lookup_local_conn(CH) of
-	[CD] when size(Reply) > MaxSz ->
+	[CD] when is_binary(Reply), byte_size(Reply) > MaxSz ->
 	    handle_send_result( send_msg(CD, lists:reverse(Reqs), Acks) ),
 	    Rep = {transactionReply, Reply},
 	    do_send_msg(CD, Rep, [], []);
diff --git a/lib/megaco/src/flex/megaco_flex_scanner.erl b/lib/megaco/src/flex/megaco_flex_scanner.erl
index 74f63b6ee3..528abd4db7 100644
--- a/lib/megaco/src/flex/megaco_flex_scanner.erl
+++ b/lib/megaco/src/flex/megaco_flex_scanner.erl
@@ -48,8 +48,8 @@ is_scanner_port(Port, Ports) when is_tuple(Ports) ->
 is_scanner_port(_, _) ->
     false.
 
-is_own_port(Port, Ports) ->
-    is_own_port(Port, size(Ports), Ports).
+is_own_port(Port, Ports) when is_tuple(Ports)->
+    is_own_port(Port, tuple_size(Ports), Ports).
 
 is_own_port(_Port, 0, _Ports) ->
     false;
diff --git a/lib/megaco/src/tcp/megaco_tcp.erl b/lib/megaco/src/tcp/megaco_tcp.erl
index 7fa7c24375..d4ecd3efb8 100644
--- a/lib/megaco/src/tcp/megaco_tcp.erl
+++ b/lib/megaco/src/tcp/megaco_tcp.erl
@@ -260,7 +260,7 @@ send_message(Socket, Data) ->
 	    
 -ifdef(megaco_debug).
 sz(Bin) when is_binary(Bin) ->
-    size(Bin);
+    byte_size(Bin);
 sz(List) when is_list(List) ->
     length(List).
 -endif.
@@ -633,11 +633,11 @@ create_acceptor(Pid, Rec, TopSup, Listen) ->
 %% Description: Function is used to add the TPKT header
 %%-----------------------------------------------------------------
 add_tpkt_header(Data) when is_binary(Data) ->
-    L = size(Data) + 4,
+    L = byte_size(Data) + 4,
     {L, [3, 0, ((L) bsr 8) band 16#ff, (L) band 16#ff ,Data]};
 add_tpkt_header(IOList) when is_list(IOList) ->
     Binary = list_to_binary(IOList),
-    L = size(Binary) + 4,
+    L = byte_size(Binary) + 4,
     {L, [3, 0, ((L) bsr 8) band 16#ff, (L) band 16#ff , Binary]}.
 
 %%-----------------------------------------------------------------
diff --git a/lib/megaco/src/tcp/megaco_tcp_connection.erl b/lib/megaco/src/tcp/megaco_tcp_connection.erl
index 0e5ea69066..090695089f 100644
--- a/lib/megaco/src/tcp/megaco_tcp_connection.erl
+++ b/lib/megaco/src/tcp/megaco_tcp_connection.erl
@@ -141,26 +141,26 @@ handle_info({tcp_error, _Socket}, TcpRec) ->
     {stop, shutdown, TcpRec};
 handle_info({tcp, Socket, <<3:8, _X:8, Length:16, Msg/binary>>}, 
 	    #megaco_tcp{socket = Socket, serialize = false} = TcpRec) 
-  when Length < ?GC_MSG_LIMIT ->
+  when is_binary(Msg), Length < ?GC_MSG_LIMIT ->
     #megaco_tcp{module = Mod, receive_handle = RH} = TcpRec,
     incNumInMessages(Socket),
-    incNumInOctets(Socket, 4+size(Msg)),
+    incNumInOctets(Socket, 4+byte_size(Msg)),
     apply(Mod, receive_message, [RH, self(), Socket, Msg]),
     _ = inet:setopts(Socket, [{active, once}]),
     {noreply, TcpRec};
 handle_info({tcp, Socket, <<3:8, _X:8, Length:16, Msg/binary>>}, 
-	    #megaco_tcp{socket = Socket, serialize = false} = TcpRec) ->
+	    #megaco_tcp{socket = Socket, serialize = false} = TcpRec) when is_binary(Msg)->
     #megaco_tcp{module = Mod, receive_handle = RH} = TcpRec,
     incNumInMessages(Socket),
-    incNumInOctets(Socket, 4+size(Msg)),
+    incNumInOctets(Socket, 4+byte_size(Msg)),
     receive_message(Mod, RH, Socket, Length, Msg),
     _ = inet:setopts(Socket, [{active, once}]),
     {noreply, TcpRec};
 handle_info({tcp, Socket, <<3:8, _X:8, _Length:16, Msg/binary>>},
-            #megaco_tcp{socket = Socket, serialize = true} = TcpRec) ->
+            #megaco_tcp{socket = Socket, serialize = true} = TcpRec) when is_binary(Msg) ->
     #megaco_tcp{module = Mod, receive_handle = RH} = TcpRec,
     incNumInMessages(Socket),
-    incNumInOctets(Socket, 4+size(Msg)),
+    incNumInOctets(Socket, 4+byte_size(Msg)),
     process_received_message(Mod, RH, Socket, Msg),
     _ = inet:setopts(Socket, [{active, once}]),
     {noreply, TcpRec};
diff --git a/lib/megaco/src/udp/megaco_udp.erl b/lib/megaco/src/udp/megaco_udp.erl
index 02ac6554a0..7253568804 100644
--- a/lib/megaco/src/udp/megaco_udp.erl
+++ b/lib/megaco/src/udp/megaco_udp.erl
@@ -223,7 +223,7 @@ send_message(SH, Data) when is_record(SH, send_handle) ->
     _ = case Res of
             ok ->
                 incNumOutMessages(SH),
-                incNumOutOctets(SH, size(Data));
+                incNumOutOctets(SH, byte_size(Data));
             _ ->
                 ok
         end,
diff --git a/lib/megaco/src/udp/megaco_udp_server.erl b/lib/megaco/src/udp/megaco_udp_server.erl
index 60914083a0..8eca33dd0e 100644
--- a/lib/megaco/src/udp/megaco_udp_server.erl
+++ b/lib/megaco/src/udp/megaco_udp_server.erl
@@ -150,10 +150,10 @@ handle_cast(Msg, UdpRec) ->
 %%              from the socket and exit codes.
 %%-----------------------------------------------------------------
 handle_info({udp, _Socket, Ip, Port, Msg}, 
-	    #megaco_udp{serialize = false} = UdpRec) ->
+	    #megaco_udp{serialize = false} = UdpRec) when is_binary(Msg) ->
     #megaco_udp{socket = Socket, module = Mod, receive_handle = RH} = UdpRec,
     SH = megaco_udp:create_send_handle(Socket, Ip, Port), 
-    MsgSize = size(Msg),
+    MsgSize = byte_size(Msg),
     incNumInMessages(SH),
     incNumInOctets(SH, MsgSize),
     case MsgSize of
@@ -165,10 +165,10 @@ handle_info({udp, _Socket, Ip, Port, Msg},
     _ = activate(Socket),
     {noreply, UdpRec};
 handle_info({udp, _Socket, Ip, Port, Msg}, 
-	    #megaco_udp{serialize = true} = UdpRec) ->
+	    #megaco_udp{serialize = true} = UdpRec) when is_binary(Msg) ->
     #megaco_udp{socket = Socket, module = Mod, receive_handle = RH} = UdpRec,
     SH = megaco_udp:create_send_handle(Socket, Ip, Port), 
-    MsgSize = size(Msg),
+    MsgSize = byte_size(Msg),
     incNumInMessages(SH),
     incNumInOctets(SH, MsgSize),
     process_received_message(Mod, RH, SH, Msg),
-- 
2.35.3

Places

File 0654-megaco-replace-size-1-by-xxx_size-1.patch of Package erlang (Revision 0c80a4377fd7b2416091869002f3c6d9)

Places