← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/ssl/src/ssl.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-08-05 20:54:29 UTC
  • mfrom: (6.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090805205429-pm4pnwew8axraosl
Tags: 1:13.b.1-dfsg-5
http://bugs.debian.org/536891
* Fixed parentheses in Emacs mode (closes: #536891).
* Removed unnecessary conflicts with erlang-manpages package.
* Added workaround for #475459: disabled threads on sparc architecture.
  This breaks wxErlang, so it's only a temporary solution.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ssl/src/ssl.erl
37
37
-include("ssl_int.hrl").
38
38
-include("ssl_internal.hrl").
39
39
 
 
40
-record(config, {ssl,               %% SSL parameters
 
41
                 inet_user,         %% User set inet options
 
42
                 emulated,          %% #socket_option{} emulated
 
43
                 inet_ssl,          %% inet options for internal ssl socket 
 
44
                 cb                 %% Callback info
 
45
                }).
 
46
 
40
47
%%--------------------------------------------------------------------
41
48
%% Function: start([, Type]) -> ok
42
49
%%
68
75
connect(Socket, SslOptions) when is_port(Socket) ->
69
76
    connect(Socket, SslOptions, infinity).
70
77
 
71
 
connect(Socket, SslOptions, Timeout) when is_port(Socket) ->
 
78
connect(Socket, SslOptions0, Timeout) when is_port(Socket) ->
72
79
    EmulatedOptions = emulated_options(),
73
 
    {ok, Inetvalues} = inet:getopts(Socket, EmulatedOptions),
 
80
    {ok, InetValues} = inet:getopts(Socket, EmulatedOptions),
74
81
    inet:setopts(Socket, internal_inet_values()), 
75
 
    try handle_options(Inetvalues ++ SslOptions, client) of
76
 
        {ok, Options0} ->
77
 
            {CbInfo, Options} =
78
 
                handle_transport_protocol(Options0),
 
82
    try handle_options(SslOptions0 ++ InetValues, client) of
 
83
        {ok, #config{cb=CbInfo, ssl=SslOptions, emulated=EmOpts}} ->
79
84
            case inet:peername(Socket) of
80
85
                {ok, {Address, Port}} ->
81
86
                    ssl_connection:connect(Address, Port, Socket, 
82
 
                                           ssl_connection_options(Options), 
83
 
                                           self(), 
84
 
                                           CbInfo, Timeout);
 
87
                                           {SslOptions, EmOpts},
 
88
                                           self(), CbInfo, Timeout);
85
89
                {error, Error} ->
86
90
                    {error, Error}
87
91
            end
102
106
            %% so that new and old ssl can be run by the same
103
107
            %% code, however the option will be ignored by old ssl
104
108
            %% that hardcodes reuseaddr to true in its portprogram.
105
 
            Options =  proplists:delete(reuseaddr, Options0),
 
109
            Options1 = proplists:delete(reuseaddr, Options0),
 
110
            Options  = proplists:delete(ssl_imp, Options1),
106
111
            old_connect(Address, Port, Options, Timeout);
107
112
        Value ->
108
113
            {error, {eoptions, {ssl_imp, Value}}}
138
143
transport_accept(ListenSocket) ->
139
144
    transport_accept(ListenSocket, infinity).
140
145
 
141
 
transport_accept(#sslsocket{pid = {ListenSocket, Options0},
 
146
transport_accept(#sslsocket{pid = {ListenSocket, #config{cb=CbInfo, ssl=SslOpts}},
142
147
                            fd = new_ssl} = SslSocket, Timeout) ->
143
 
    {{CbModule, _, _} = CbInfo, {SSlOpts, EmOpts, _}} =
144
 
        handle_transport_protocol(Options0),
 
148
    
 
149
    %% The setopt could have been invoked on the listen socket
 
150
    %% and options should be inherited.
 
151
    EmOptions = emulated_options(),
 
152
    {ok, InetValues} = inet:getopts(ListenSocket, EmOptions),
 
153
    {CbModule,_,_} = CbInfo,
145
154
    {ok, Socket} = CbModule:accept(ListenSocket, Timeout),
 
155
    inet:setopts(Socket, internal_inet_values()),
146
156
    {ok, Port} = inet:port(Socket),
147
157
    case ssl_connection_sup:start_child([server, "localhost", Port, Socket,
148
 
                                         {SSlOpts, EmOpts}, self(),
 
158
                                         {SslOpts, socket_options(InetValues)}, self(),
149
159
                                         CbInfo]) of
150
160
        {ok, Pid} ->
151
161
            CbModule:controlling_process(Socket, Pid),
193
203
    ensure_old_ssl_started(),
194
204
    ssl_broker:ssl_accept(Socket, Timeout).
195
205
 
196
 
ssl_accept(ListenSocket, SslOptions, Timeout) when is_port(ListenSocket) -> 
197
 
     EmulatedOptions = emulated_options(),
198
 
    {ok, Inetvalues} = inet:getopts(ListenSocket, EmulatedOptions),
199
 
    inet:setopts(ListenSocket, internal_inet_values()), 
200
 
    try handle_options(Inetvalues ++ SslOptions, server) of
201
 
        {ok, Options} ->
202
 
            {{_, _, _} = CbInfo, {SSlOpts, EmOpts, _}} =
203
 
                handle_transport_protocol(Options),
204
 
            {ok, Port} = inet:port(ListenSocket),
205
 
            ssl_connection:accept(Port, ListenSocket, 
206
 
                                  {SSlOpts, EmOpts}, self(), CbInfo, Timeout)
 
206
ssl_accept(Socket, SslOptions, Timeout) when is_port(Socket) -> 
 
207
    EmulatedOptions = emulated_options(),
 
208
    {ok, InetValues} = inet:getopts(Socket, EmulatedOptions),
 
209
    inet:setopts(Socket, internal_inet_values()), 
 
210
    try handle_options(SslOptions ++ InetValues, server) of
 
211
        {ok, #config{cb=CbInfo,ssl=SslOpts, emulated=EmOpts}} ->
 
212
            {ok, Port} = inet:port(Socket),
 
213
            ssl_connection:accept(Port, Socket,
 
214
                                  {SslOpts, EmOpts},
 
215
                                  self(), CbInfo, Timeout)
207
216
    catch 
208
 
        {error, Reason} ->
209
 
            {error, Reason}
 
217
        Error = {error, _Reason} -> Error
210
218
    end.
211
219
 
212
220
%%--------------------------------------------------------------------
214
222
%%
215
223
%% Description: Close a ssl connection
216
224
%%--------------------------------------------------------------------  
217
 
close(#sslsocket{pid = {ListenSocket, {_,_, Options}}, fd = new_ssl}) ->
218
 
    {CbModule, _, _} = proplists:get_value(cb_info, Options),
219
 
    CbModule:close(ListenSocket);
 
225
close(#sslsocket{pid = {ListenSocket, #config{cb={CbMod,_, _}}}, fd = new_ssl}) ->
 
226
    CbMod:close(ListenSocket);
220
227
close(#sslsocket{pid = Pid, fd = new_ssl}) ->
221
228
    ssl_connection:close(Pid);
222
229
close(Socket = #sslsocket{}) ->
348
355
%%--------------------------------------------------------------------
349
356
getopts(#sslsocket{fd = new_ssl, pid = Pid}, OptTags) when is_pid(Pid) ->
350
357
    ssl_connection:get_opts(Pid, OptTags);
351
 
getopts(#sslsocket{fd = new_ssl, 
352
 
                   pid = {ListenSocket, {_, EmOpts, _}}}, OptTags) ->
353
 
    getopts(ListenSocket, EmOpts, OptTags, []);
 
358
getopts(#sslsocket{fd = new_ssl, pid = {ListenSocket, _}}, OptTags) ->
 
359
    inet:getopts(ListenSocket, OptTags);
354
360
getopts(#sslsocket{} = Socket, Options) ->
355
361
    ensure_old_ssl_started(),
356
362
    ssl_broker:getopts(Socket, Options).
360
366
%% 
361
367
%% Description:
362
368
%%--------------------------------------------------------------------
363
 
setopts(#sslsocket{fd = new_ssl, pid = Pid}, Options) ->
 
369
setopts(#sslsocket{fd = new_ssl, pid = Pid}, Options) when is_pid(Pid) ->
364
370
    ssl_connection:set_opts(Pid, Options);
 
371
setopts(#sslsocket{fd = new_ssl, pid = {ListenSocket, _}}, OptTags) ->
 
372
    inet:setopts(ListenSocket, OptTags);
365
373
setopts(#sslsocket{} = Socket, Options) ->
366
374
    ensure_old_ssl_started(),
367
375
    ssl_broker:setopts(Socket, Options).
371
379
%% 
372
380
%% Description: Same as gen_tcp:shutdown/2
373
381
%%--------------------------------------------------------------------
374
 
shutdown(#sslsocket{pid = {ListenSocket, Opts}, fd = new_ssl}, How) ->
375
 
    {{CbModule, _,_}, _} = handle_transport_protocol(Opts),
376
 
    CbModule:shutdown(ListenSocket, How);
 
382
shutdown(#sslsocket{pid = {ListenSocket, #config{cb={CbMod,_, _}}}, fd = new_ssl}, How) ->
 
383
    CbMod:shutdown(ListenSocket, How);
377
384
shutdown(#sslsocket{pid = Pid, fd = new_ssl}, How) ->
378
385
    ssl_connection:shutdown(Pid, How).
379
386
 
434
441
%%%--------------------------------------------------------------------
435
442
new_connect(Address, Port, Options, Timeout) when is_list(Options) ->
436
443
    try handle_options(Options, client) of
437
 
        {ok, NewOptions} ->
438
 
            do_new_connect(Address, Port, NewOptions, Timeout)
 
444
        {ok, Config} ->
 
445
            do_new_connect(Address,Port,Config,Timeout)
439
446
    catch 
440
 
         {error, Reason} ->
441
 
            {error, Reason}
 
447
        throw:Error ->
 
448
            Error
442
449
    end.
443
450
 
444
 
do_new_connect(Address, Port, Options0, Timeout) ->
445
 
    {{CbModule, _, _} = CbInfo, Options} =
446
 
        handle_transport_protocol(Options0),
447
 
    try CbModule:connect(Address, Port, 
448
 
                         connect_options(Options), Timeout) of
 
451
do_new_connect(Address, Port,
 
452
               #config{cb=CbInfo, inet_user=UserOpts, ssl=SslOpts,
 
453
                       emulated=EmOpts,inet_ssl=SocketOpts},
 
454
               Timeout) ->
 
455
    {CbModule, _, _} = CbInfo,    
 
456
    try CbModule:connect(Address, Port,  SocketOpts, Timeout) of
449
457
        {ok, Socket} ->
450
 
            ssl_connection:connect(Address, Port, Socket, 
451
 
                                   ssl_connection_options(Options), self(), 
452
 
                                   CbInfo, Timeout);
 
458
            ssl_connection:connect(Address, Port, Socket, {SslOpts,EmOpts},
 
459
                                   self(), CbInfo, Timeout);
453
460
        {error, Reason} ->
454
461
            {error, Reason}
455
462
    catch
456
463
        exit:{function_clause, _} ->
457
 
            {error, {}};
458
 
          exit:{badarg, _} ->
459
 
            {error,{eoptions, {inet_options, connect_options(Options)}}}
460
 
 
 
464
            {error, {eoptions, {cb_info, CbInfo}}};
 
465
        exit:{badarg, _} ->
 
466
            {error,{eoptions, {inet_options, UserOpts}}}
461
467
    end.
462
468
 
463
 
handle_transport_protocol({SSL, Emulated, Options0}) ->
464
 
    CbInfo = 
465
 
        proplists:get_value(cb_info, Options0, {gen_tcp, tcp, tcp_closed}),
466
 
    Options = proplists:delete(cb_info, Options0),
467
 
    {CbInfo, {SSL, Emulated, Options}}.
468
 
 
469
469
old_connect(Address, Port, Options, Timeout) ->
470
470
    ensure_old_ssl_started(),
471
471
    {ok, Pid} = ssl_broker:start_broker(connector),
472
472
    ssl_broker:connect(Pid, Address, Port, Options, Timeout).
473
473
 
474
474
new_listen(Port, Options0) ->
475
 
    try handle_options(Options0, server) of
476
 
        {ok, Options1} ->
477
 
            {CbInfo, Options} =
478
 
                handle_transport_protocol(Options1),
479
 
            new_listen(CbInfo, Port, Options)
 
475
    try 
 
476
        {ok, Config} = handle_options(Options0, server),
 
477
        #config{cb={CbModule, _, _},inet_user=Options} = Config,
 
478
        case CbModule:listen(Port, Options) of
 
479
            {ok, ListenSocket} ->
 
480
                {ok, #sslsocket{pid = {ListenSocket, Config}, fd = new_ssl}};
 
481
            Err = {error, _} ->
 
482
                Err
 
483
        end
480
484
    catch 
481
 
        {error, Reason} ->
482
 
            {error, Reason}
483
 
    end.
484
 
 
485
 
new_listen({CbModule, _, _} = CbInfo, Port, Options) ->
486
 
    case CbModule:listen(Port, listen_options(Options)) of
487
 
        {ok, ListenSocket} ->
488
 
            {SslOpts, EmOpts} = ssl_listen_options(Options),
489
 
            {ok, #sslsocket{pid = {ListenSocket, {SslOpts, EmOpts, 
490
 
                                                  [{cb_info, CbInfo}]}},
491
 
                                   fd = new_ssl}};
492
 
        {error, Reason} ->
493
 
            {error, Reason} 
 
485
        Error = {error, _} ->
 
486
            Error
494
487
    end.
495
488
            
496
489
old_listen(Port, Options) ->
502
495
    Opts = proplists:expand([{binary, [{mode, binary}]},
503
496
                             {list, [{mode, list}]}], Opts0),
504
497
    
505
 
    ReuseSessionFun = fun(_, _, _, _) ->
506
 
                              true
507
 
                      end,
 
498
    ReuseSessionFun = fun(_, _, _, _) -> true end,
 
499
 
 
500
    AcceptBadCa = fun({bad_cert,unknown_ca}, Acc) ->  Acc;
 
501
                     (Other, Acc) -> [Other | Acc]
 
502
                  end,
508
503
    
509
 
    VerifyFun =  fun(ErrorList) ->
510
 
                         case lists:foldl(fun({bad_cert,unknown_ca}, Acc) ->
511
 
                                                  Acc;
512
 
                                             (Other, Acc) ->
513
 
                                                  [Other | Acc]
514
 
                                          end, [], ErrorList) of
515
 
                             [] ->
516
 
                                 true;
517
 
                             [_|_] ->
518
 
                                 false
519
 
                         end
520
 
                 end,
 
504
    VerifyFun =
 
505
        fun(ErrorList) ->
 
506
                case lists:foldl(AcceptBadCa, [], ErrorList) of
 
507
                    [] ->    true;
 
508
                    [_|_] -> false
 
509
                end
 
510
        end,
521
511
 
522
 
    {Verify, FailIfNoPeerCert, CaCertDefalut} = 
 
512
    {Verify, FailIfNoPeerCert, CaCertDefault} = 
523
513
        %% Handle 0, 1, 2 for backwards compatibility
524
514
        case proplists:get_value(verify, Opts, verify_none) of
525
515
            0 ->
526
 
                {verify_none, false, ca_cert_defalut(verify_none, Role)};
 
516
                {verify_none, false, ca_cert_default(verify_none, Role)};
527
517
            1  ->
528
 
                {verify_peer, false, ca_cert_defalut(verify_peer, Role)};
 
518
                {verify_peer, false, ca_cert_default(verify_peer, Role)};
529
519
            2 ->
530
 
                {verify_peer, true,  ca_cert_defalut(verify_peer, Role)};
 
520
                {verify_peer, true,  ca_cert_default(verify_peer, Role)};
531
521
            verify_none ->
532
 
                {verify_none, false, ca_cert_defalut(verify_none, Role)};
 
522
                {verify_none, false, ca_cert_default(verify_none, Role)};
533
523
            verify_peer ->
534
524
                {verify_peer, proplists:get_value(fail_if_no_peer_cert,
535
525
                                                  Opts, false),
536
 
                 ca_cert_defalut(verify_peer, Role)};
 
526
                 ca_cert_default(verify_peer, Role)};
537
527
            Value ->
538
528
                throw({error, {eoptions, {verify, Value}}})
539
529
        end,   
552
542
      keyfile    = handle_option(keyfile,  Opts, CertFile),
553
543
      key        = handle_option(key, Opts, undefined),
554
544
      password   = handle_option(password, Opts, ""),
555
 
      cacertfile = handle_option(cacertfile, Opts, CaCertDefalut),
 
545
      cacertfile = handle_option(cacertfile, Opts, CaCertDefault),
556
546
      ciphers    = handle_option(ciphers, Opts, []),
557
547
      %% Server side option
558
548
      reuse_session = handle_option(reuse_session, Opts, ReuseSessionFun),
559
549
      reuse_sessions = handle_option(reuse_sessions, Opts, true),
560
550
      debug      = handle_option(debug, Opts, [])
561
551
     },
562
 
    EmulatedSockOpts = #socket_options{
563
 
      mode    = handle_option(mode, Opts, list),
564
 
      packet  = handle_option(packet, Opts, 0),
565
 
      header  = handle_option(header, Opts, 0),
566
 
      active  = handle_option(active, Opts, true)
567
 
     },
 
552
 
 
553
    CbInfo  = proplists:get_value(cb_info, Opts, {gen_tcp, tcp, tcp_closed}),    
 
554
    SslOptions = [versions, verify, verify_fun, 
 
555
                  depth, certfile, keyfile,
 
556
                  key, password, cacertfile, ciphers,
 
557
                  debug, reuse_session, reuse_sessions, ssl_imp,
 
558
                  cd_info],
568
559
    
569
 
    SslOREmulated = [versions, verify, verify_fun, 
570
 
                     depth, certfile, keyfile,
571
 
                     key, password, cacertfile, ciphers,
572
 
                     debug, mode, packet, header, active,
573
 
                     reuse_session, reuse_sessions, ssl_imp],
574
 
 
575
560
    SockOpts = lists:foldl(fun(Key, PropList) -> 
576
 
                                    proplists:delete(Key, PropList)
577
 
                            end, Opts, SslOREmulated),
 
561
                                   proplists:delete(Key, PropList)
 
562
                           end, Opts, SslOptions),
578
563
    
579
 
    {ok, {SSLOptions, EmulatedSockOpts, SockOpts}}.
 
564
    {SSLsock, Emulated} = emulated_options(SockOpts),
 
565
    {ok, #config{ssl=SSLOptions, emulated=Emulated, inet_ssl=SSLsock,
 
566
                 inet_user=SockOpts, cb=CbInfo}}.
580
567
 
581
568
handle_option(OptionName, Opts, Default) ->
582
569
    validate_option(OptionName, 
634
621
validate_option(reuse_sessions, Value) when Value == true; 
635
622
                                            Value == false ->
636
623
    Value;
637
 
validate_option(mode, Value) when Value == list;
638
 
                                  Value == binary ->
639
 
    Value;
640
 
 
641
 
validate_option(packet, Value) when Value == raw;
642
 
                                    Value == 0;
643
 
                                    Value == 1;
644
 
                                    Value == 2;
645
 
                                    Value == 4;
646
 
                                    Value == asn1;
647
 
                                    Value == fcgi;
648
 
                                    Value == sunrm;
649
 
                                    Value == http;
650
 
                                    Value == httph;
651
 
                                    Value == cdr;
652
 
                                    Value == tpkt;
653
 
                                    Value == line  ->
654
 
    Value;
655
 
validate_option(header, Value)  when is_integer(Value) ->
656
 
    Value;
657
 
validate_option(active, Value) when Value == true;
658
 
                                    Value == false;
659
 
                                    Value == once ->
660
 
    
661
 
    Value;
662
624
validate_option(debug, Value) when is_list(Value); Value == true ->
663
625
    Value;
664
626
validate_option(Opt, Value) ->
673
635
validate_versions(Ver, Versions) ->
674
636
    throw({error, {eoptions, {Ver, {versions, Versions}}}}).
675
637
 
676
 
ca_cert_defalut(verify_none, _) ->
 
638
validate_inet_option(mode, Value)
 
639
  when Value =/= list, Value =/= binary ->
 
640
    throw({error, {eoptions, {mode,Value}}});
 
641
validate_inet_option(packet, Value)
 
642
  when not (is_atom(Value) or is_integer(Value)) ->
 
643
    throw({error, {eoptions, {packet,Value}}});
 
644
validate_inet_option(packet_size, Value)
 
645
  when not is_integer(Value) ->
 
646
    throw({error, {eoptions, {packet_size,Value}}});
 
647
validate_inet_option(header, Value)
 
648
  when not is_integer(Value) ->
 
649
    throw({error, {eoptions, {header,Value}}});
 
650
validate_inet_option(active, Value)
 
651
  when Value =/= true, Value =/= false, Value =/= once ->
 
652
    throw({error, {eoptions, {active,Value}}});
 
653
validate_inet_option(_, _) ->
 
654
    ok.
 
655
 
 
656
ca_cert_default(verify_none, _) ->
677
657
    undefined;
678
658
%% Client may leave verification up to the user
679
 
ca_cert_defalut(verify_peer, client) ->
 
659
ca_cert_default(verify_peer, client) ->
680
660
    undefined;
681
661
%% Server that wants to verify_peer must have
682
662
%% some trusted certs.
683
 
ca_cert_defalut(verify_peer, server) ->
 
663
ca_cert_default(verify_peer, server) ->
684
664
    "".
685
665
 
686
 
listen_options({_, _, InetOpts}) ->
687
 
    %% Packet, mode, active and header must be  
688
 
    %% emulated. 
689
 
    internal_inet_values() ++ InetOpts.
690
 
 
691
 
ssl_listen_options({SslOpts, SocketOpts, _}) ->
692
 
    {SslOpts, SocketOpts}.
693
 
 
694
 
connect_options({_, _, InetOpts}) ->
695
 
    %% Packet, mode, active and header must be  
696
 
    %% emulated. 
697
 
    internal_inet_values() ++ InetOpts.
698
 
 
699
666
emulated_options() ->
700
 
    [mode, packet, active, header].
 
667
    [mode, packet, active, header, packet_size].
701
668
 
702
669
internal_inet_values() ->
703
 
    [{packet, 0},{header, 0},{active, false},{mode,binary}].
 
670
    [{packet_size,0},{packet, 0},{header, 0},{active, false},{mode,binary}].
704
671
    %%[{packet, ssl},{header, 0},{active, false},{mode,binary}].
705
672
 
706
 
ssl_connection_options({SslOpts, SocketOpts, _}) ->
707
 
    {SslOpts, SocketOpts}.
 
673
socket_options(InetValues) ->
 
674
    #socket_options{
 
675
                mode   = proplists:get_value(mode, InetValues),
 
676
                header = proplists:get_value(header, InetValues),
 
677
                active = proplists:get_value(active, InetValues),
 
678
                packet = proplists:get_value(packet, InetValues),
 
679
                packet_size = proplists:get_value(packet_size, InetValues)           
 
680
               }.
 
681
 
 
682
emulated_options(Opts) ->
 
683
    emulated_options(Opts, internal_inet_values(), #socket_options{}).
 
684
 
 
685
emulated_options([{mode,Opt}|Opts], Inet, Emulated) ->
 
686
    validate_inet_option(mode,Opt),
 
687
    emulated_options(Opts, Inet, Emulated#socket_options{mode=Opt});
 
688
emulated_options([{header,Opt}|Opts], Inet, Emulated) ->
 
689
    validate_inet_option(header,Opt),
 
690
    emulated_options(Opts, Inet, Emulated#socket_options{header=Opt});
 
691
emulated_options([{active,Opt}|Opts], Inet, Emulated) ->
 
692
    validate_inet_option(active,Opt),
 
693
    emulated_options(Opts, Inet, Emulated#socket_options{active=Opt});
 
694
emulated_options([{packet,Opt}|Opts], Inet, Emulated) ->
 
695
    validate_inet_option(packet,Opt),
 
696
    emulated_options(Opts, Inet, Emulated#socket_options{packet=Opt});
 
697
emulated_options([{packet_size,Opt}|Opts], Inet, Emulated) ->
 
698
    validate_inet_option(packet_size,Opt),
 
699
    emulated_options(Opts, Inet, Emulated#socket_options{packet_size=Opt});
 
700
emulated_options([Opt|Opts], Inet, Emulated) ->
 
701
    emulated_options(Opts, [Opt|Inet], Emulated);
 
702
emulated_options([], Inet,Emulated) ->
 
703
    {Inet, Emulated}.
708
704
 
709
705
cipher_suites(Version, []) ->
710
706
    ssl_cipher:suites(Version);
809
805
no_format(Error) ->    
810
806
    io_lib:format("No format string for error: \"~p\" available.", [Error]).
811
807
 
812
 
getopts(_, _, [], Acc) ->
813
 
    {ok, Acc};
814
 
getopts(Socket, Options, [mode | Rest], Acc) ->
815
 
    Value = {mode, Options#socket_options.mode},
816
 
    getopts(Socket, Options, Rest, [Value | Acc]);
817
 
getopts(Socket, Options, [packet | Rest], Acc) ->
818
 
    Value =  {packet, Options#socket_options.packet},
819
 
    getopts(Socket, Options, Rest, [Value | Acc]);
820
 
getopts(Socket, Options, [header | Rest], Acc) ->
821
 
    Value = {header, Options#socket_options.header},
822
 
    getopts(Socket, Options, Rest, [Value | Acc]);
823
 
getopts(Socket, Options, [active | Rest], Acc) ->
824
 
    Value = {active, Options#socket_options.active},
825
 
    getopts(Socket, Options, Rest, [Value | Acc]);
826
 
getopts(Socket, Options, [Tag | Rest], Acc) ->
827
 
    {ok, [Value]} = inet:getopts(Socket, Tag),
828
 
    getopts(Socket, Options, Rest, [Value | Acc]).
829
 
 
830
808
%% Start old ssl port program if needed.
831
809
ensure_old_ssl_started() ->
832
810
    case whereis(ssl_server) of