anchor.diff:  proxyauth_without_response(Header) ->
       case keylist:fetch("Proxy-Authorization", Header) of
   	[] -> none;
  -    ProxyAuth ->
  -	AuthDict = sipheader:auth(ProxyAuth),
  -	NewDict1 = dict:erase("response", AuthDict),
  -	NewDict2 = dict:erase("nonce", NewDict1),
  -	NewDict3 = dict:erase("cnonce", NewDict2),
  -	NewDict4 = dict:erase("opaque", NewDict3),
  -	sipheader:dict_to_param(NewDict4)
  +	ProxyAuth ->
  +	    AuthDict = sipheader:auth(ProxyAuth),
  +	    NewDict1 = dict:erase("response", AuthDict),
  +	    NewDict2 = dict:erase("nonce", NewDict1),
  +	    NewDict3 = dict:erase("cnonce", NewDict2),
  +	    NewDict4 = dict:erase("opaque", NewDict3),
  +	    sipheader:dict_to_param(NewDict4)
       end.
   
   check_valid_proxy_request("ACK", _) ->
  
positive.code:     {Protocol, {Host, DestPort}, Parameters} = Dest,
      ParamDict = sipheader:param_to_dict(Parameters),
      SendToHost = case dict:find("received", ParamDict) of
  	{ok, Received} ->
  	    case regexp:first_match(Received, "^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$") of
  		{match, _, _} ->
  		    Received;
  		_ ->
  		    logger:log(debug, "Malformed received= parameter (not an IP address): ~p", [Received]),
  		    Host
  	    end;
  	Res ->
  	    Host
      end,
      {Port, PortInt} = case dict:find("rport", ParamDict) of
  	{ok, []} ->
  	    % This must be an error response generated before the rport fix-up. Ignore rport.
  	    {DestPort, list_to_integer(default_port(DestPort))};
  	{ok, Rport} ->
  	    {Rport, list_to_integer(Rport)};
  	_ ->
  	    {DestPort, list_to_integer(default_port(DestPort))}
      end,
      SendSocket = case sipsocket:is_good_socket(DefaultSocket) of
  	true ->
  	    DefaultSocket;
  	_ ->
  	    logger:log(debug, "Siprequest: No good socket (~p) provided to send_response_to() - asking transport layer",
  			[DefaultSocket]),
  	    case sipsocket:get_socket(sipsocket:via2sipsocketprotocol(Protocol), SendToHost,
  					   PortInt) of
  		{error, E1} ->
  		    {error, E1};
  		none ->
  		    {error, "no socket provided and get_socket() returned 'none'"};
  		S when record(S, sipsocket) ->
  		    S
  	    end
      end,
      case SendSocket of
  	SipSocket when record(SipSocket, sipsocket) ->
  	    CPid = SipSocket#sipsocket.pid,
  	    logger:log(debug, "send response(top Via: ~s, send to=~s:~s:~p (using ~p)) :~n~s~n",
      			[sipheader:via_print([Dest]), sipsocket:sipproto2str(SipSocket), SendToHost, PortInt, CPid, Message]),
  	    case sipsocket:send(SendSocket, SendToHost, PortInt, Message) of
  		ok ->
  		    ok;
  		{error, E} ->
  		    logger:log(error, "Failed sending response to ~s:~p using socket ~p, error ~p",
  				[SendToHost, PortInt, SendSocket, E]),
  		    {senderror, E}
  	    end;
  	{error, E} ->
  	    logger:log(error, "Failed to get socket to send response to ~s:~p, error ~p, response :~n~s~n",
  			[SendToHost, PortInt, E, Message]),
  	    {senderror, "Could not get socket"}
      end.
  
  
negative.code:     end.
  
  host_port_to_dstlist(InHost, InPort, ApproxMsgSize) ->
      %% RFC3263 4.1 says we SHOULD use UDP if port is explicitly provided
      %% except if other things (such as packet > 1300 bytes) suggests use
      %% of other transport
      case dnsutil:get_ip_port(InHost, default_port(InPort)) of
  	{error, What} ->
  	    {error, What};
  