%%
%% %CopyrightBegin%
%% 
%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
%% 
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%% 
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%% 
%% %CopyrightEnd%
%%

%%

%% Purpose: Primitive interface to SSL, without broker process (used by 
%% SSL distribution).

-module(ssl_prim).

-export([listen/2, connect/3, accept/1, close/1, send/2, send/3, recv/2, recv/3,
	 getll/1, getstat/2, setopts/2, controlling_process/2, peername/1,
	 sockname/1, getif/1]).

-include("ssl_int.hrl").
-include("ssl_broker_int.hrl").

%-define(filter(Call), filter((catch Call))).
-define(filter(Call), filter(Call)).

listen(Port, Opts) ->
    St = newstate(listener),
    ?filter(ssl_broker:listen_prim(ssl_server_prim, self(), Port, nonactive(Opts), St)).

connect(Address, Port, Opts) ->
    St = newstate(connector),
    ?filter(ssl_broker:connect_prim(ssl_server_prim, inet_tcp, self(), Address, 
				    Port, nonactive(Opts), infinity, St)).

accept(#st{} = ListenSt0) ->
    case transport_accept(ListenSt0) of
	{ok, ListenSt1} ->
	    ssl_accept(ListenSt0, ListenSt1);
	Error ->
	    Error
    end.

transport_accept(#st{opts = ListenOpts, thissock = ListenSocket}) ->
    NewSt = newstate(acceptor),
    ListenFd = ListenSocket#sslsocket.fd,
    ?filter(ssl_broker:transport_accept_prim(ssl_server_prim, ListenFd,
					     ListenOpts, infinity, NewSt)).

ssl_accept(#st{opts = LOpts}, ListenSt1) ->
    ?filter(ssl_broker:ssl_accept_prim(ssl_server_prim, gen_tcp, self(),
				       LOpts, infinity, ListenSt1)).

close(#st{fd = Fd}) when is_integer(Fd) ->
    ssl_server:close_prim(ssl_server_prim, Fd),
    ok;
close(_) ->
    ok.

send(St, Data) ->
    send(St, Data, []).

send(#st{proxysock = Proxysock, status = open}, Data, Opts) ->
    case inet_tcp:send(Proxysock, Data, Opts) of
	ok ->
	    ok;
	{error, _} ->
	    {error, closed}
    end;
send(#st{}, _Data, _Opts) ->
    {error, closed}.

recv(St, Length) ->
    recv(St, Length, infinity).

recv(#st{proxysock = Proxysock, status = open}, Length, Tmo) ->
    inet_tcp:recv(Proxysock, Length, Tmo);
recv(#st{}, _Length, _Tmo) ->
    {error, closed}.

getll(#st{proxysock = Proxysock, status = open})  ->
    inet:getll(Proxysock);
getll(#st{}) ->
    {error, closed}.

getstat(#st{proxysock = Proxysock, status = open}, Opts) ->
    inet:getstat(Proxysock, Opts);
getstat(#st{}, _Opts) ->
    {error, closed}.

setopts(#st{proxysock = Proxysock, status = open}, Opts) ->
    case remove_supported(Opts) of
	[] ->
	    inet:setopts(Proxysock, Opts);
	_ ->
	    {error, enotsup}
    end;
setopts(#st{}, _Opts) ->
    {error, closed}.


controlling_process(#st{proxysock = Proxysock, status = open}, Pid)
  when is_pid(Pid) ->
    inet_tcp:controlling_process(Proxysock, Pid);
controlling_process(#st{}, Pid) when is_pid(Pid) ->
    {error, closed}.

peername(#st{fd = Fd, status = open}) ->
    case ssl_server:peername_prim(ssl_server_prim, Fd) of
	{ok, {Address, Port}} ->
	    {ok, At} = inet_parse:ipv4_address(Address),
	    {ok, {At, Port}};
	Error ->
	    Error
    end;
peername(#st{}) ->
    {error, closed}.

sockname(#st{fd = Fd, status = open}) ->
    case ssl_server:sockname_prim(ssl_server_prim, Fd) of
	{ok, {Address, Port}} ->
	    {ok, At} = inet_parse:ipv4_address(Address),
	    {ok, {At, Port}};
	Error ->
	    Error
    end;
sockname(#st{}) ->
    {error, closed}.

getif(#st{proxysock = Proxysock, status = open}) ->
    inet:getif(Proxysock);
getif(#st{}) ->
    {error, closed}.

remove_supported([{active, _}|T]) ->
    remove_supported(T);
remove_supported([{packet,_}|T]) ->
    remove_supported(T);
remove_supported([{deliver,_}|T]) ->
    remove_supported(T);
remove_supported([H|T]) ->
    [H | remove_supported(T)];
remove_supported([]) ->
    [].

filter(Result) ->
    case Result of
	{ok, _Sock,St} ->
	    {ok, St};
        {error, Reason, _St} ->
	    {error,Reason}
    end.

nonactive([{active,_}|T]) ->
    nonactive(T);
nonactive([H|T]) ->
    [H | nonactive(T)];
nonactive([]) ->
    [{active, false}].

newstate(Type) ->
   #st{brokertype = Type, server = whereis(ssl_server_prim),
       client = undefined, collector = undefined, debug = false}.