← Back to branch summary

~clint-fewbar/ubuntu/precise/erlang/merge-15b

« back to all changes in this revision

Viewing changes to lib/orber/src/orber_iiop_net.erl

  • Committer: Package Import Robot
  • Author(s): Sergei Golovan
  • Date: 2011-12-15 19:20:10 UTC
  • mfrom: (1.1.18) (3.5.15 sid)
  • mto: (3.5.16 sid)
  • mto: This revision was merged to the branch mainline in revision 33.
  • Revision ID: package-import@ubuntu.com-20111215192010-jnxcfe3tbrpp0big
Tags: 1:15.b-dfsg-1
* New upstream release.
* Upload to experimental because this release breaks external drivers
  API along with ABI, so several applications are to be fixed.
* Removed SSL patch because the old SSL implementation is removed from
  the upstream distribution.
* Removed never used patch which added native code to erlang beam files.
* Removed the erlang-docbuilder binary package because the docbuilder
  application was dropped by upstream.
* Documented dropping ${erlang-docbuilder:Depends} substvar in
  erlang-depends(1) manpage.
* Made erlang-base and erlang-base-hipe provide virtual package
  erlang-abi-15.b (the number means the first erlang version, which
  provides current ABI).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/orber/src/orber_iiop_net.erl
2
2
%%
3
3
%% %CopyrightBegin%
4
4
%% 
5
 
%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
 
5
%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
6
6
%% 
7
7
%% The contents of this file are subject to the Erlang Public License,
8
8
%% Version 1.1, (the "License"); you may not use this file except in
161
161
%%-----------------------------------------------------------------
162
162
get_options(normal, _Options) ->
163
163
    [];
164
 
get_options(ssl, Options) ->
165
 
    Verify = orber_tb:keysearch(ssl_server_verify, Options, 
166
 
                                orber_env:ssl_server_verify()),
167
 
    Depth = orber_tb:keysearch(ssl_server_depth, Options, 
168
 
                               orber_env:ssl_server_depth()),
169
 
    Cert = orber_tb:keysearch(ssl_server_certfile, Options, 
170
 
                              orber_env:ssl_server_certfile()),
171
 
    CaCert = orber_tb:keysearch(ssl_server_cacertfile, Options, 
172
 
                                orber_env:ssl_server_cacertfile()),
173
 
    Pwd = orber_tb:keysearch(ssl_server_password, Options, 
174
 
                             orber_env:ssl_server_password()),
175
 
    Key = orber_tb:keysearch(ssl_server_keyfile, Options, 
176
 
                               orber_env:ssl_server_keyfile()),
177
 
    Ciphers = orber_tb:keysearch(ssl_server_ciphers, Options, 
178
 
                                 orber_env:ssl_server_ciphers()),
179
 
    Timeout = orber_tb:keysearch(ssl_server_cachetimeout, Options, 
180
 
                                 orber_env:ssl_server_cachetimeout()),
181
 
    [{verify, Verify},
182
 
     {depth, Depth} |
183
 
     ssl_server_extra_options([{certfile, Cert},
184
 
                               {cacertfile, CaCert},
185
 
                               {password, Pwd},
186
 
                               {keyfile, Key},
187
 
                               {ciphers, Ciphers},
188
 
                               {cachetimeout, Timeout}], [])].
 
164
get_options(ssl, Options) ->    
 
165
    SSLOpts = 
 
166
        case orber_tb:keysearch(ssl_server_options, Options,
 
167
                                orber_env:ssl_server_options()) of
 
168
            [] ->
 
169
                Verify = orber_tb:keysearch(ssl_server_verify, Options, 
 
170
                                            orber_env:ssl_server_verify()),
 
171
                Depth = orber_tb:keysearch(ssl_server_depth, Options, 
 
172
                                           orber_env:ssl_server_depth()),
 
173
                Cert = orber_tb:keysearch(ssl_server_certfile, Options, 
 
174
                                          orber_env:ssl_server_certfile()),
 
175
                CaCert = orber_tb:keysearch(ssl_server_cacertfile, Options, 
 
176
                                            orber_env:ssl_server_cacertfile()),
 
177
                Pwd = orber_tb:keysearch(ssl_server_password, Options, 
 
178
                                         orber_env:ssl_server_password()),
 
179
                Key = orber_tb:keysearch(ssl_server_keyfile, Options, 
 
180
                                         orber_env:ssl_server_keyfile()),
 
181
                Ciphers = orber_tb:keysearch(ssl_server_ciphers, Options, 
 
182
                                             orber_env:ssl_server_ciphers()),
 
183
                Timeout = orber_tb:keysearch(ssl_server_cachetimeout, Options, 
 
184
                                             orber_env:ssl_server_cachetimeout()),
 
185
                KeepAlive = orber_tb:keysearch(ssl_server_cachetimeout, Options, 
 
186
                                               orber_env:iiop_ssl_in_keepalive()),
 
187
                [{verify, Verify},
 
188
                 {depth, Depth},
 
189
                 {certfile, Cert},
 
190
                 {cacertfile, CaCert},
 
191
                 {password, Pwd},
 
192
                 {keyfile, Key},
 
193
                 {ciphers, Ciphers},
 
194
                 {cachetimeout, Timeout},
 
195
                 {keepalive, KeepAlive}];
 
196
            Opts ->     
 
197
                case orber_tb:check_illegal_tcp_options(Opts) of
 
198
                    ok -> 
 
199
                        check_old_ssl_server_options(Options),
 
200
                        Opts;
 
201
                    {error, IllegalOpts} ->
 
202
                        error_logger:error_report([{application, orber},
 
203
                                                   "TCP options not allowed to set on a connection", 
 
204
                                                   IllegalOpts]),
 
205
                        error("Illegal TCP option")
 
206
                end
 
207
        end,
 
208
    ssl_server_extra_options(SSLOpts, []).
189
209
 
190
210
%%-----------------------------------------------------------------
191
211
%% Func: parse_options/2
266
286
    Family = orber_env:ip_version(),
267
287
    case inet:getaddr(IP, Family) of
268
288
        {ok, IPTuple} ->
269
 
            Options = [{ip, IPTuple}|get_options(Type, AllOptions)],
270
 
            Ref = make_ref(),
271
 
            ProxyOptions = filter_options(AllOptions, []),
272
 
            case orber_socket:listen(Type, Port, Options, false) of
273
 
                {ok, Listen, NewPort} ->
274
 
                    {ok, Pid} = orber_iiop_socketsup:start_accept(Type, Listen, Ref,
275
 
                                                                  ProxyOptions),
276
 
                    link(Pid),
277
 
                    ets:insert(?CONNECTION_DB, #listen{pid = Pid, 
278
 
                                                       socket = Listen, 
279
 
                                                       port = NewPort, 
280
 
                                                       type = Type, ref = Ref,
281
 
                                                       options = Options,
282
 
                                                       proxy_options = ProxyOptions}),
283
 
                    {reply, {ok, Ref}, State};
284
 
                Error ->
285
 
                    {reply, Error, State}
 
289
            try [{ip, IPTuple} |get_options(Type, AllOptions)] of
 
290
                Options ->
 
291
                    Ref = make_ref(),
 
292
                    ProxyOptions = filter_options(AllOptions, []),
 
293
                    case orber_socket:listen(Type, Port, Options, false) of
 
294
                        {ok, Listen, NewPort} ->
 
295
                            {ok, Pid} = orber_iiop_socketsup:start_accept(Type, Listen, Ref,
 
296
                                                                          ProxyOptions),
 
297
                            link(Pid),
 
298
                            ets:insert(?CONNECTION_DB, #listen{pid = Pid, 
 
299
                                                               socket = Listen, 
 
300
                                                               port = NewPort, 
 
301
                                                               type = Type, ref = Ref,
 
302
                                                               options = Options,
 
303
                                                               proxy_options = ProxyOptions}),
 
304
                            {reply, {ok, Ref}, State};
 
305
                        Error ->
 
306
                            {reply, Error, State}
 
307
                    end
 
308
            catch
 
309
                error:Reason ->
 
310
                    {reply, {error, Reason}, State}
286
311
            end;
287
312
        Other ->
288
313
            {reply, Other, State}
461
486
update_counter(State, Value) ->
462
487
    State#state{counter = State#state.counter + Value}.
463
488
 
 
489
 
 
490
check_old_ssl_server_options(Options) ->
 
491
    try
 
492
        0 = orber_tb:keysearch(ssl_server_verify, Options, 
 
493
                               orber_env:ssl_server_verify()),
 
494
        1 = orber_tb:keysearch(ssl_server_depth, Options, 
 
495
                               orber_env:ssl_server_depth()),
 
496
        [] = orber_tb:keysearch(ssl_server_certfile, Options, 
 
497
                                orber_env:ssl_server_certfile()),
 
498
        [] = orber_tb:keysearch(ssl_server_cacertfile, Options, 
 
499
                                orber_env:ssl_server_cacertfile()),
 
500
        [] = orber_tb:keysearch(ssl_server_password, Options, 
 
501
                                orber_env:ssl_server_password()),
 
502
        [] = orber_tb:keysearch(ssl_server_keyfile, Options, 
 
503
                                orber_env:ssl_server_keyfile()),
 
504
        [] = orber_tb:keysearch(ssl_server_ciphers, Options, 
 
505
                                orber_env:ssl_server_ciphers()),
 
506
        infinity = orber_tb:keysearch(ssl_server_cachetimeout, Options, 
 
507
                                      orber_env:ssl_server_cachetimeout()),
 
508
        false = orber_tb:keysearch(iiop_ssl_in_keepalive, Options, 
 
509
                                   orber_env:iiop_ssl_in_keepalive())
 
510
    catch
 
511
        _:_ ->
 
512
                                              io:format("hej\n",[]),
 
513
            error_logger:warning_report([{application, orber},
 
514
                         "Ignoring deprecated ssl server options used together with the ssl_server_options"])
 
515
    end.
 
516