4
%% Copyright Ericsson AB 2008-2011. All Rights Reserved.
6
%% The contents of this file are subject to the Erlang Public License,
7
%% Version 1.1, (the "License"); you may not use this file except in
8
%% compliance with the License. You should have received a copy of the
9
%% Erlang Public License along with this software. If not, it can be
10
%% retrieved online at http://www.erlang.org/.
12
%% Software distributed under the License is distributed on an "AS IS"
13
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
14
%% the License for the specific language governing rights and limitations
21
-module(ssl_packet_SUITE).
23
%% Note: This directive should only be used in test suites.
26
-include_lib("common_test/include/ct.hrl").
28
-define(BYTE(X), X:8/unsigned-big-integer).
29
-define(UINT16(X), X:16/unsigned-big-integer).
30
-define(UINT24(X), X:24/unsigned-big-integer).
31
-define(UINT32(X), X:32/unsigned-big-integer).
32
-define(UINT64(X), X:64/unsigned-big-integer).
33
-define(STRING(X), ?UINT32((size(X))), (X)/binary).
35
-define(byte(X), << ?BYTE(X) >> ).
36
-define(uint16(X), << ?UINT16(X) >> ).
37
-define(uint24(X), << ?UINT24(X) >> ).
38
-define(uint32(X), << ?UINT32(X) >> ).
39
-define(uint64(X), << ?UINT64(X) >> ).
40
-define(TIMEOUT, 120000).
45
%% Test server callback functions
46
%%--------------------------------------------------------------------
47
%% Function: init_per_suite(Config) -> Config
49
%% A list of key/value pairs, holding the test case configuration.
50
%% Description: Initialization before the whole suite
52
%% Note: This function is free to add any key/value pairs to the Config
53
%% variable, but should NOT alter/remove any existing entries.
54
%%--------------------------------------------------------------------
55
init_per_suite(Config) ->
58
application:start(public_key),
61
(catch make_certs:all(?config(data_dir, Config),
62
?config(priv_dir, Config))),
63
test_server:format("Make certs ~p~n", [Result]),
64
ssl_test_lib:cert_options(Config)
66
{skip, "Crypto did not start"}
68
%%--------------------------------------------------------------------
69
%% Function: end_per_suite(Config) -> _
71
%% A list of key/value pairs, holding the test case configuration.
72
%% Description: Cleanup after the whole suite
73
%%--------------------------------------------------------------------
74
end_per_suite(_Config) ->
76
application:stop(crypto).
78
%%--------------------------------------------------------------------
79
%% Function: init_per_testcase(TestCase, Config) -> Config
81
%% Name of the test case that is about to be run.
83
%% A list of key/value pairs, holding the test case configuration.
85
%% Description: Initialization before each test case
87
%% Note: This function is free to add any key/value pairs to the Config
88
%% variable, but should NOT alter/remove any existing entries.
89
%% Description: Initialization before each test case
90
%%--------------------------------------------------------------------
91
init_per_testcase(_TestCase, Config0) ->
92
Config = lists:keydelete(watchdog, 1, Config0),
93
Dog = ssl_test_lib:timetrap(?TIMEOUT),
94
[{watchdog, Dog} | Config].
96
%%--------------------------------------------------------------------
97
%% Function: end_per_testcase(TestCase, Config) -> _
99
%% Name of the test case that is about to be run.
100
%% Config - [tuple()]
101
%% A list of key/value pairs, holding the test case configuration.
102
%% Description: Cleanup after each test case
103
%%--------------------------------------------------------------------
104
end_per_testcase(_TestCase, Config) ->
105
Dog = ?config(watchdog, Config),
110
test_server:timetrap_cancel(Dog)
113
%%--------------------------------------------------------------------
114
%% Function: all(Clause) -> TestCases
115
%% Clause - atom() - suite | doc
116
%% TestCases - [Case]
118
%% Name of a test case.
119
%% Description: Returns a list of all test cases in this test suite
120
%%--------------------------------------------------------------------
121
suite() -> [{ct_hooks,[ts_install_cth]}].
124
[packet_raw_passive_many_small,
125
packet_0_passive_many_small,
126
packet_1_passive_many_small,
127
packet_2_passive_many_small,
128
packet_4_passive_many_small,
129
packet_raw_passive_some_big, packet_0_passive_some_big,
130
packet_1_passive_some_big, packet_2_passive_some_big,
131
packet_4_passive_some_big,
132
packet_raw_active_once_many_small,
133
packet_0_active_once_many_small,
134
packet_1_active_once_many_small,
135
packet_2_active_once_many_small,
136
packet_4_active_once_many_small,
137
packet_raw_active_once_some_big,
138
packet_0_active_once_some_big,
139
packet_1_active_once_some_big,
140
packet_2_active_once_some_big,
141
packet_4_active_once_some_big,
142
packet_raw_active_many_small,
143
packet_0_active_many_small, packet_1_active_many_small,
144
packet_2_active_many_small, packet_4_active_many_small,
145
packet_raw_active_some_big, packet_0_active_some_big,
146
packet_1_active_some_big, packet_2_active_some_big,
147
packet_4_active_some_big, packet_send_to_large,
148
packet_wait_passive, packet_wait_active,
149
packet_baddata_passive, packet_baddata_active,
150
packet_size_passive, packet_size_active,
151
packet_cdr_decode, packet_cdr_decode_list,
152
packet_http_decode, packet_http_decode_list,
153
packet_http_bin_decode_multi, packet_http_error_passive,
154
packet_line_decode, packet_line_decode_list,
155
packet_asn1_decode, packet_asn1_decode_list,
156
packet_tpkt_decode, packet_tpkt_decode_list,
157
packet_sunrm_decode, packet_sunrm_decode_list,
158
header_decode_one_byte, header_decode_two_bytes,
159
header_decode_two_bytes_one_sent,
160
header_decode_two_bytes_two_sent].
165
init_per_group(_GroupName, Config) ->
168
end_per_group(_GroupName, Config) ->
172
%% Test cases starts here.
173
%%--------------------------------------------------------------------
174
packet_raw_passive_many_small(doc) ->
175
["Test packet option {packet, raw} in passive mode."];
177
packet_raw_passive_many_small(suite) ->
180
packet_raw_passive_many_small(Config) when is_list(Config) ->
181
ClientOpts = ?config(client_opts, Config),
182
ServerOpts = ?config(server_opts, Config),
183
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
185
Data = "Packet option is {packet, raw}",
187
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
189
{mfa, {?MODULE, send_raw ,[Data, ?MANY]}},
190
{options, ServerOpts}]),
191
Port = ssl_test_lib:inet_port(Server),
192
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
195
{mfa, {?MODULE, passive_raw, [Data, ?MANY]}},
201
ssl_test_lib:check_result(Client, ok),
203
ssl_test_lib:close(Server),
204
ssl_test_lib:close(Client).
206
%%--------------------------------------------------------------------
208
packet_raw_passive_some_big(doc) ->
209
["Test packet option {packet, raw} in passive mode."];
211
packet_raw_passive_some_big(suite) ->
214
packet_raw_passive_some_big(Config) when is_list(Config) ->
215
ClientOpts = ?config(client_opts, Config),
216
ServerOpts = ?config(server_opts, Config),
217
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
219
Data = lists:append(lists:duplicate(100, "1234567890")),
221
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
223
{mfa, {?MODULE, send_raw ,[Data, ?SOME]}},
224
{options, ServerOpts}]),
225
Port = ssl_test_lib:inet_port(Server),
226
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
229
{mfa, {?MODULE, passive_raw, [Data, ?SOME]}},
235
ssl_test_lib:check_result(Client, ok),
237
ssl_test_lib:close(Server),
238
ssl_test_lib:close(Client).
240
%%--------------------------------------------------------------------
241
packet_0_passive_many_small(doc) ->
242
["Test packet option {packet, 0} in passive mode."];
244
packet_0_passive_many_small(suite) ->
247
packet_0_passive_many_small(Config) when is_list(Config) ->
248
ClientOpts = ?config(client_opts, Config),
249
ServerOpts = ?config(server_opts, Config),
250
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
252
Data = "Packet option is {packet, 0}, equivalent to packet raw.",
254
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
256
{mfa, {?MODULE, send_raw ,[Data, ?MANY]}},
257
{options, ServerOpts}]),
258
Port = ssl_test_lib:inet_port(Server),
259
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
262
{mfa, {?MODULE, passive_raw, [Data, ?MANY]}},
263
{options, [{active, false},
267
ssl_test_lib:check_result(Client, ok),
269
ssl_test_lib:close(Server),
270
ssl_test_lib:close(Client).
272
%%--------------------------------------------------------------------
273
packet_0_passive_some_big(doc) ->
274
["Test packet option {packet, 0} in passive mode."];
276
packet_0_passive_some_big(suite) ->
279
packet_0_passive_some_big(Config) when is_list(Config) ->
280
ClientOpts = ?config(client_opts, Config),
281
ServerOpts = ?config(server_opts, Config),
282
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
284
Data = lists:append(lists:duplicate(100, "1234567890")),
286
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
288
{mfa, {?MODULE, send_raw ,[Data, ?SOME]}},
289
{options, ServerOpts}]),
290
Port = ssl_test_lib:inet_port(Server),
291
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
294
{mfa, {?MODULE, passive_raw, [Data, ?SOME]}},
295
{options, [{active, false},
299
ssl_test_lib:check_result(Client, ok),
301
ssl_test_lib:close(Server),
302
ssl_test_lib:close(Client).
304
%%--------------------------------------------------------------------
305
packet_1_passive_many_small(doc) ->
306
["Test packet option {packet, 1} in passive mode."];
308
packet_1_passive_many_small(suite) ->
311
packet_1_passive_many_small(Config) when is_list(Config) ->
312
ClientOpts = ?config(client_opts, Config),
313
ServerOpts = ?config(server_opts, Config),
314
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
316
Data = "Packet option is {packet, 1}",
318
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
320
{mfa, {?MODULE, send, [Data, ?MANY]}},
321
{options, [{packet, 1}|ServerOpts]}]),
322
Port = ssl_test_lib:inet_port(Server),
323
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
326
{mfa, {?MODULE, passive_recv_packet,
328
{options, [{active, false},
332
ssl_test_lib:check_result(Client, ok),
334
ssl_test_lib:close(Server),
335
ssl_test_lib:close(Client).
337
%%--------------------------------------------------------------------
338
packet_1_passive_some_big(doc) ->
339
["Test packet option {packet, 1} in passive mode."];
341
packet_1_passive_some_big(suite) ->
344
packet_1_passive_some_big(Config) when is_list(Config) ->
345
ClientOpts = ?config(client_opts, Config),
346
ServerOpts = ?config(server_opts, Config),
347
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
349
Data = lists:append(lists:duplicate(255, "1")),
351
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
353
{mfa, {?MODULE, send, [Data, ?SOME]}},
354
{options, [{packet, 1}|ServerOpts]}]),
355
Port = ssl_test_lib:inet_port(Server),
356
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
359
{mfa, {?MODULE, passive_recv_packet,
361
{options, [{active, false},
365
ssl_test_lib:check_result(Client, ok),
367
ssl_test_lib:close(Server),
368
ssl_test_lib:close(Client).
370
%%--------------------------------------------------------------------
371
packet_2_passive_many_small(doc) ->
372
["Test packet option {packet, 2} in passive mode"];
374
packet_2_passive_many_small(suite) ->
377
packet_2_passive_many_small(Config) when is_list(Config) ->
378
ClientOpts = ?config(client_opts, Config),
379
ServerOpts = ?config(server_opts, Config),
380
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
382
Data = "Packet option is {packet, 2}",
384
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
386
{mfa, {?MODULE, send, [Data, ?MANY]}},
387
{options, [{packet, 2}|ServerOpts]}]),
388
Port = ssl_test_lib:inet_port(Server),
389
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
392
{mfa, {?MODULE, passive_recv_packet,
394
{options, [{active, false},
398
ssl_test_lib:check_result(Client, ok),
400
ssl_test_lib:close(Server),
401
ssl_test_lib:close(Client).
403
%%--------------------------------------------------------------------
404
packet_2_passive_some_big(doc) ->
405
["Test packet option {packet, 2} in passive mode"];
407
packet_2_passive_some_big(suite) ->
410
packet_2_passive_some_big(Config) when is_list(Config) ->
411
ClientOpts = ?config(client_opts, Config),
412
ServerOpts = ?config(server_opts, Config),
413
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
415
Data = lists:append(lists:duplicate(100, "1234567890")),
417
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
419
{mfa, {?MODULE, send, [Data, ?SOME]}},
420
{options, [{packet, 2}|ServerOpts]}]),
421
Port = ssl_test_lib:inet_port(Server),
422
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
425
{mfa, {?MODULE, passive_recv_packet,
427
{options, [{active, false},
431
ssl_test_lib:check_result(Client, ok),
433
ssl_test_lib:close(Server),
434
ssl_test_lib:close(Client).
436
%%--------------------------------------------------------------------
437
packet_4_passive_many_small(doc) ->
438
["Test packet option {packet, 4} in passive mode"];
440
packet_4_passive_many_small(suite) ->
443
packet_4_passive_many_small(Config) when is_list(Config) ->
444
ClientOpts = ?config(client_opts, Config),
445
ServerOpts = ?config(server_opts, Config),
446
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
448
Data = "Packet option is {packet, 4}",
450
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
453
{?MODULE, send, [Data, ?MANY]}},
454
{options, [{packet, 4}|ServerOpts]}]),
455
Port = ssl_test_lib:inet_port(Server),
456
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
459
{mfa, {?MODULE, passive_recv_packet,
461
{options, [{active, false},
465
ssl_test_lib:check_result(Client, ok),
467
ssl_test_lib:close(Server),
468
ssl_test_lib:close(Client).
470
%%--------------------------------------------------------------------
471
packet_4_passive_some_big(doc) ->
472
["Test packet option {packet, 4} in passive mode"];
474
packet_4_passive_some_big(suite) ->
477
packet_4_passive_some_big(Config) when is_list(Config) ->
478
ClientOpts = ?config(client_opts, Config),
479
ServerOpts = ?config(server_opts, Config),
480
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
482
Data = lists:append(lists:duplicate(100, "1234567890")),
484
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
486
{mfa, {?MODULE, send, [Data, ?SOME]}},
487
{options, [{packet, 4}|ServerOpts]}]),
488
Port = ssl_test_lib:inet_port(Server),
489
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
492
{mfa, {?MODULE, passive_recv_packet,
494
{options, [{active, false},
498
ssl_test_lib:check_result(Client, ok),
500
ssl_test_lib:close(Server),
501
ssl_test_lib:close(Client).
504
%%--------------------------------------------------------------------
505
packet_raw_active_once_many_small(doc) ->
506
["Test packet option {packet, raw} in active once mode."];
508
packet_raw_active_once_many_small(suite) ->
511
packet_raw_active_once_many_small(Config) when is_list(Config) ->
512
ClientOpts = ?config(client_opts, Config),
513
ServerOpts = ?config(server_opts, Config),
514
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
516
Data = "Packet option is {packet, raw}",
518
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
520
{mfa, {?MODULE, send_raw ,[Data, ?MANY]}},
521
{options, ServerOpts}]),
522
Port = ssl_test_lib:inet_port(Server),
523
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
526
{mfa, {?MODULE, active_once_raw,
528
{options, [{active, once},
532
ssl_test_lib:check_result(Client, ok),
534
ssl_test_lib:close(Server),
535
ssl_test_lib:close(Client).
537
%%--------------------------------------------------------------------
538
packet_raw_active_once_some_big(doc) ->
539
["Test packet option {packet, raw} in active once mode."];
541
packet_raw_active_once_some_big(suite) ->
544
packet_raw_active_once_some_big(Config) when is_list(Config) ->
545
ClientOpts = ?config(client_opts, Config),
546
ServerOpts = ?config(server_opts, Config),
547
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
549
Data = lists:append(lists:duplicate(100, "1234567890")),
551
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
553
{mfa, {?MODULE, send_raw ,[Data, ?SOME]}},
554
{options, ServerOpts}]),
555
Port = ssl_test_lib:inet_port(Server),
556
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
559
{mfa, {?MODULE, active_once_raw,
561
{options, [{active, once},
565
ssl_test_lib:check_result(Client, ok),
567
ssl_test_lib:close(Server),
568
ssl_test_lib:close(Client).
570
%%--------------------------------------------------------------------
571
packet_0_active_once_many_small(doc) ->
572
["Test packet option {packet, 0} in active once mode."];
574
packet_0_active_once_many_small(suite) ->
577
packet_0_active_once_many_small(Config) when is_list(Config) ->
578
ClientOpts = ?config(client_opts, Config),
579
ServerOpts = ?config(server_opts, Config),
580
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
582
Data = "Packet option is {packet, 0}",
584
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
586
{mfa, {?MODULE, send_raw ,[Data, ?MANY]}},
587
{options, ServerOpts}]),
588
Port = ssl_test_lib:inet_port(Server),
589
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
593
{?MODULE, active_once_raw,
595
{options, [{active, once},
599
ssl_test_lib:check_result(Client, ok),
601
ssl_test_lib:close(Server),
602
ssl_test_lib:close(Client).
605
%%--------------------------------------------------------------------
606
packet_0_active_once_some_big(doc) ->
607
["Test packet option {packet, 0} in active once mode."];
609
packet_0_active_once_some_big(suite) ->
612
packet_0_active_once_some_big(Config) when is_list(Config) ->
613
ClientOpts = ?config(client_opts, Config),
614
ServerOpts = ?config(server_opts, Config),
615
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
617
Data = lists:append(lists:duplicate(100, "1234567890")),
619
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
621
{mfa, {?MODULE, send_raw ,
623
{options, ServerOpts}]),
624
Port = ssl_test_lib:inet_port(Server),
625
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
629
{?MODULE, active_once_raw,
631
{options, [{active, once},
635
ssl_test_lib:check_result(Client, ok),
637
ssl_test_lib:close(Server),
638
ssl_test_lib:close(Client).
640
%%--------------------------------------------------------------------
641
packet_1_active_once_many_small(doc) ->
642
["Test packet option {packet, 1} in active once mode."];
644
packet_1_active_once_many_small(suite) ->
647
packet_1_active_once_many_small(Config) when is_list(Config) ->
648
ClientOpts = ?config(client_opts, Config),
649
ServerOpts = ?config(server_opts, Config),
650
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
652
Data = "Packet option is {packet, 1}",
654
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
656
{mfa, {?MODULE, send, [Data, ?MANY]}},
657
{options, [{packet, 1}|ServerOpts]}]),
658
Port = ssl_test_lib:inet_port(Server),
659
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
666
{options, [{active, once},
670
ssl_test_lib:check_result(Client, ok),
672
ssl_test_lib:close(Server),
673
ssl_test_lib:close(Client).
675
%%--------------------------------------------------------------------
676
packet_1_active_once_some_big(doc) ->
677
["Test packet option {packet, 1} in active once mode."];
679
packet_1_active_once_some_big(suite) ->
682
packet_1_active_once_some_big(Config) when is_list(Config) ->
683
ClientOpts = ?config(client_opts, Config),
684
ServerOpts = ?config(server_opts, Config),
685
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
687
Data = lists:append(lists:duplicate(255, "1")),
689
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
691
{mfa, {?MODULE, send, [Data, ?SOME]}},
692
{options, [{packet, 1}|ServerOpts]}]),
693
Port = ssl_test_lib:inet_port(Server),
694
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
701
{options, [{active, once},
705
ssl_test_lib:check_result(Client, ok),
707
ssl_test_lib:close(Server),
708
ssl_test_lib:close(Client).
710
%%--------------------------------------------------------------------
711
packet_2_active_once_many_small(doc) ->
712
["Test packet option {packet, 2} in active once mode"];
714
packet_2_active_once_many_small(suite) ->
717
packet_2_active_once_many_small(Config) when is_list(Config) ->
718
ClientOpts = ?config(client_opts, Config),
719
ServerOpts = ?config(server_opts, Config),
720
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
722
Data = "Packet option is {packet, 2}",
724
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
726
{mfa, {?MODULE, send, [Data, ?MANY]}},
727
{options, [{packet, 2}|ServerOpts]}]),
728
Port = ssl_test_lib:inet_port(Server),
729
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
736
{options, [{active, once},
740
ssl_test_lib:check_result(Client, ok),
742
ssl_test_lib:close(Server),
743
ssl_test_lib:close(Client).
746
%%--------------------------------------------------------------------
747
packet_2_active_once_some_big(doc) ->
748
["Test packet option {packet, 2} in active once mode"];
750
packet_2_active_once_some_big(suite) ->
753
packet_2_active_once_some_big(Config) when is_list(Config) ->
754
ClientOpts = ?config(client_opts, Config),
755
ServerOpts = ?config(server_opts, Config),
756
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
758
Data = lists:append(lists:duplicate(100, "1234567890")),
760
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
762
{mfa, {?MODULE, send, [Data, ?SOME]}},
763
{options, [{packet, 2}|ServerOpts]}]),
764
Port = ssl_test_lib:inet_port(Server),
765
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
772
{options, [{active, once},
776
ssl_test_lib:check_result(Client, ok),
778
ssl_test_lib:close(Server),
779
ssl_test_lib:close(Client).
781
%%--------------------------------------------------------------------
782
packet_4_active_once_many_small(doc) ->
783
["Test packet option {packet, 4} in active once mode"];
785
packet_4_active_once_many_small(suite) ->
788
packet_4_active_once_many_small(Config) when is_list(Config) ->
789
ClientOpts = ?config(client_opts, Config),
790
ServerOpts = ?config(server_opts, Config),
791
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
793
Data = "Packet option is {packet, 4}",
795
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
797
{mfa, {?MODULE, send, [Data, ?MANY]}},
798
{options, [{packet, 4}|ServerOpts]}]),
799
Port = ssl_test_lib:inet_port(Server),
800
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
807
{options, [{active, once},
811
ssl_test_lib:check_result(Client, ok),
813
ssl_test_lib:close(Server),
814
ssl_test_lib:close(Client).
816
%%--------------------------------------------------------------------
817
packet_4_active_once_some_big(doc) ->
818
["Test packet option {packet, 4} in active once mode"];
820
packet_4_active_once_some_big(suite) ->
823
packet_4_active_once_some_big(Config) when is_list(Config) ->
824
ClientOpts = ?config(client_opts, Config),
825
ServerOpts = ?config(server_opts, Config),
826
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
828
Data = lists:append(lists:duplicate(100, "1234567890")),
830
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
832
{mfa, {?MODULE, send, [Data, ?SOME]}},
833
{options, [{packet, 4}|ServerOpts]}]),
834
Port = ssl_test_lib:inet_port(Server),
835
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
842
{options, [{active, once},
846
ssl_test_lib:check_result(Client, ok),
848
ssl_test_lib:close(Server),
849
ssl_test_lib:close(Client).
851
%%--------------------------------------------------------------------
852
packet_raw_active_many_small(doc) ->
853
["Test packet option {packet, raw} in active mode."];
855
packet_raw_active_many_small(suite) ->
858
packet_raw_active_many_small(Config) when is_list(Config) ->
859
ClientOpts = ?config(client_opts, Config),
860
ServerOpts = ?config(server_opts, Config),
861
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
863
Data = "Packet option is {packet, raw}",
865
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
867
{mfa, {?MODULE, send_raw ,[Data, ?MANY]}},
868
{options, ServerOpts}]),
869
Port = ssl_test_lib:inet_port(Server),
870
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
873
{mfa, {?MODULE, active_raw,
875
{options, [{active, true},
879
ssl_test_lib:check_result(Client, ok),
881
ssl_test_lib:close(Server),
882
ssl_test_lib:close(Client).
885
%%--------------------------------------------------------------------
886
packet_raw_active_some_big(doc) ->
887
["Test packet option {packet, raw} in active mode."];
889
packet_raw_active_some_big(suite) ->
892
packet_raw_active_some_big(Config) when is_list(Config) ->
893
ClientOpts = ?config(client_opts, Config),
894
ServerOpts = ?config(server_opts, Config),
895
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
897
Data = lists:append(lists:duplicate(100, "1234567890")),
899
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
901
{mfa, {?MODULE, send_raw ,[Data, ?SOME]}},
902
{options, ServerOpts}]),
903
Port = ssl_test_lib:inet_port(Server),
904
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
907
{mfa, {?MODULE, active_raw, [Data, ?SOME]}},
908
{options, [{active, true},
912
ssl_test_lib:check_result(Client, ok),
914
ssl_test_lib:close(Server),
915
ssl_test_lib:close(Client).
917
%%--------------------------------------------------------------------
918
packet_0_active_many_small(doc) ->
919
["Test packet option {packet, 0} in active mode."];
921
packet_0_active_many_small(suite) ->
924
packet_0_active_many_small(Config) when is_list(Config) ->
925
ClientOpts = ?config(client_opts, Config),
926
ServerOpts = ?config(server_opts, Config),
927
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
929
Data = "Packet option is {packet, 0}",
931
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
933
{mfa, {?MODULE, send_raw ,[Data, ?MANY]}},
934
{options, ServerOpts}]),
935
Port = ssl_test_lib:inet_port(Server),
936
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
940
{?MODULE, active_raw,
942
{options, [{active, true},
946
ssl_test_lib:check_result(Client, ok),
948
ssl_test_lib:close(Server),
949
ssl_test_lib:close(Client).
951
%%--------------------------------------------------------------------
952
packet_0_active_some_big(doc) ->
953
["Test packet option {packet, 0} in active mode."];
955
packet_0_active_some_big(suite) ->
958
packet_0_active_some_big(Config) when is_list(Config) ->
959
ClientOpts = ?config(client_opts, Config),
960
ServerOpts = ?config(server_opts, Config),
961
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
963
Data = lists:append(lists:duplicate(100, "1234567890")),
965
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
967
{mfa, {?MODULE, send_raw ,[Data, ?SOME]}},
968
{options, ServerOpts}]),
969
Port = ssl_test_lib:inet_port(Server),
970
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
974
{?MODULE, active_raw,
976
{options, [{active, true},
980
ssl_test_lib:check_result(Client, ok),
982
ssl_test_lib:close(Server),
983
ssl_test_lib:close(Client).
986
%%--------------------------------------------------------------------
987
packet_1_active_many_small(doc) ->
988
["Test packet option {packet, 1} in active mode."];
990
packet_1_active_many_small(suite) ->
993
packet_1_active_many_small(Config) when is_list(Config) ->
994
ClientOpts = ?config(client_opts, Config),
995
ServerOpts = ?config(server_opts, Config),
996
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
998
Data = "Packet option is {packet, 1}",
1000
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1002
{mfa, {?MODULE, send, [Data, ?MANY]}},
1003
{options, [{packet, 1}|ServerOpts]}]),
1004
Port = ssl_test_lib:inet_port(Server),
1005
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1010
active_packet, [Data, ?MANY]}},
1011
{options, [{active, true},
1015
ssl_test_lib:check_result(Client, ok),
1017
ssl_test_lib:close(Server),
1018
ssl_test_lib:close(Client).
1020
%%--------------------------------------------------------------------
1021
packet_1_active_some_big(doc) ->
1022
["Test packet option {packet, 1} in active mode."];
1024
packet_1_active_some_big(suite) ->
1027
packet_1_active_some_big(Config) when is_list(Config) ->
1028
ClientOpts = ?config(client_opts, Config),
1029
ServerOpts = ?config(server_opts, Config),
1030
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1032
Data = lists:append(lists:duplicate(255, "1")),
1034
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1036
{mfa, {?MODULE, send, [Data, ?SOME]}},
1037
{options, [{packet, 1}|ServerOpts]}]),
1038
Port = ssl_test_lib:inet_port(Server),
1039
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1044
active_packet, [Data, ?SOME]}},
1045
{options, [{active, true},
1049
ssl_test_lib:check_result(Client, ok),
1051
ssl_test_lib:close(Server),
1052
ssl_test_lib:close(Client).
1054
%%--------------------------------------------------------------------
1055
packet_2_active_many_small(doc) ->
1056
["Test packet option {packet, 2} in active mode"];
1058
packet_2_active_many_small(suite) ->
1061
packet_2_active_many_small(Config) when is_list(Config) ->
1062
ClientOpts = ?config(client_opts, Config),
1063
ServerOpts = ?config(server_opts, Config),
1064
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1066
Data = "Packet option is {packet, 2}",
1068
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1070
{mfa, {?MODULE, send, [Data, ?MANY]}},
1071
{options, [{packet, 2}|ServerOpts]}]),
1072
Port = ssl_test_lib:inet_port(Server),
1073
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1078
active_packet, [Data, ?MANY]}},
1079
{options, [{active, true},
1083
ssl_test_lib:check_result(Client, ok),
1085
ssl_test_lib:close(Server),
1086
ssl_test_lib:close(Client).
1088
%%--------------------------------------------------------------------
1089
packet_2_active_some_big(doc) ->
1090
["Test packet option {packet, 2} in active mode"];
1092
packet_2_active_some_big(suite) ->
1095
packet_2_active_some_big(Config) when is_list(Config) ->
1096
ClientOpts = ?config(client_opts, Config),
1097
ServerOpts = ?config(server_opts, Config),
1098
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1100
Data = lists:append(lists:duplicate(100, "1234567890")),
1102
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1104
{mfa, {?MODULE, send, [Data, ?SOME]}},
1105
{options, [{packet, 2}|ServerOpts]}]),
1106
Port = ssl_test_lib:inet_port(Server),
1107
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1112
active_packet, [Data, ?SOME]}},
1113
{options, [{active, true},
1117
ssl_test_lib:check_result(Client, ok),
1119
ssl_test_lib:close(Server),
1120
ssl_test_lib:close(Client).
1122
%%--------------------------------------------------------------------
1123
packet_4_active_many_small(doc) ->
1124
["Test packet option {packet, 4} in active mode"];
1126
packet_4_active_many_small(suite) ->
1129
packet_4_active_many_small(Config) when is_list(Config) ->
1130
ClientOpts = ?config(client_opts, Config),
1131
ServerOpts = ?config(server_opts, Config),
1132
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1134
Data = "Packet option is {packet, 4}",
1136
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1138
{mfa, {?MODULE, send, [Data, ?MANY]}},
1139
{options, [{packet, 4}|ServerOpts]}]),
1140
Port = ssl_test_lib:inet_port(Server),
1141
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1146
active_packet, [Data, ?MANY]}},
1147
{options, [{active, true},
1151
ssl_test_lib:check_result(Client, ok),
1153
ssl_test_lib:close(Server),
1154
ssl_test_lib:close(Client).
1157
%%--------------------------------------------------------------------
1158
packet_4_active_some_big(doc) ->
1159
["Test packet option {packet, 4} in active mode"];
1161
packet_4_active_some_big(suite) ->
1164
packet_4_active_some_big(Config) when is_list(Config) ->
1165
ClientOpts = ?config(client_opts, Config),
1166
ServerOpts = ?config(server_opts, Config),
1167
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1169
Data = lists:append(lists:duplicate(100, "1234567890")),
1171
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1173
{mfa, {?MODULE, send, [Data, ?SOME]}},
1174
{options, [{packet, 4} | ServerOpts]}]),
1175
Port = ssl_test_lib:inet_port(Server),
1176
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1181
active_packet, [Data, ?SOME]}},
1182
{options, [{active, true},
1186
ssl_test_lib:check_result(Client, ok),
1188
ssl_test_lib:close(Server),
1189
ssl_test_lib:close(Client).
1192
%%--------------------------------------------------------------------
1193
packet_send_to_large(doc) ->
1194
["Test setting the packet option {packet, 2} on the send side"];
1196
packet_send_to_large(suite) -> [];
1198
packet_send_to_large(Config) when is_list(Config) ->
1199
ClientOpts = ?config(client_opts, Config),
1200
ServerOpts = ?config(server_opts, Config),
1201
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1203
Data = lists:append(lists:duplicate(30, "1234567890")),
1205
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1207
{mfa, {?MODULE, send, [Data, 1]}},
1208
{options, [{packet, 1}| ServerOpts]}]),
1209
Port = ssl_test_lib:inet_port(Server),
1210
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1213
{mfa, {?MODULE, active_packet, [Data, 1]}},
1214
{options, [{active, true} | ClientOpts]}]),
1216
ssl_test_lib:check_result(Server, {error, {badarg,
1217
{packet_to_large, 300, 255}}}),
1219
ssl_test_lib:close(Server),
1220
ssl_test_lib:close(Client).
1226
%%--------------------------------------------------------------------
1227
packet_wait_active(doc) ->
1228
["Test waiting when complete packages have not arrived"];
1230
packet_wait_active(suite) ->
1233
packet_wait_active(Config) when is_list(Config) ->
1234
ClientOpts = ?config(client_opts, Config),
1235
ServerOpts = ?config(server_opts, Config),
1236
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1238
Data = list_to_binary(lists:duplicate(100, "1234567890")),
1240
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1242
{mfa, {?MODULE, send_incomplete,
1244
{options, ServerOpts}]),
1245
Port = ssl_test_lib:inet_port(Server),
1246
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1250
{?MODULE, active_packet,
1251
[binary_to_list(Data), ?SOME]}},
1252
{options, [{active, true},
1256
ssl_test_lib:check_result(Client, ok),
1258
ssl_test_lib:close(Server),
1259
ssl_test_lib:close(Client).
1262
%%--------------------------------------------------------------------
1263
packet_wait_passive(doc) ->
1264
["Test waiting when complete packages have not arrived"];
1266
packet_wait_passive(suite) ->
1269
packet_wait_passive(Config) when is_list(Config) ->
1270
ClientOpts = ?config(client_opts, Config),
1271
ServerOpts = ?config(server_opts, Config),
1272
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1274
Data = list_to_binary(lists:duplicate(100, "1234567890")),
1276
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1278
{mfa, {?MODULE, send_incomplete,
1280
{options, ServerOpts}]),
1281
Port = ssl_test_lib:inet_port(Server),
1282
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1285
{mfa, {?MODULE, passive_recv_packet,
1286
[binary_to_list(Data), ?SOME]}},
1287
{options, [{active, false},
1291
ssl_test_lib:check_result(Client, ok),
1293
ssl_test_lib:close(Server),
1294
ssl_test_lib:close(Client).
1295
%%--------------------------------------------------------------------
1296
packet_baddata_active(doc) ->
1297
["Test that if a bad packet arrives error msg is sent and socket is closed"];
1298
packet_baddata_active(suite) ->
1301
packet_baddata_active(Config) when is_list(Config) ->
1302
ClientOpts = ?config(client_opts, Config),
1303
ServerOpts = ?config(server_opts, Config),
1304
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1306
Data = list_to_binary(lists:duplicate(100, "1234567890")),
1308
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1310
{mfa, {?MODULE, send_incomplete ,[Data, 1]}},
1311
{options, ServerOpts}]),
1312
Port = ssl_test_lib:inet_port(Server),
1313
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1316
{mfa, {?MODULE, active_packet, [Data, 1]}},
1317
{options, [{active, true},
1321
{Client, {other, {ssl_error, _Socket,
1322
{invalid_packet, _}},{error,closed},1}} -> ok;
1324
test_server:fail({unexpected, Unexpected})
1328
ssl_test_lib:close(Server),
1329
ssl_test_lib:close(Client).
1330
%%--------------------------------------------------------------------
1331
packet_baddata_passive(doc) ->
1332
["Test that if a bad packet arrives error msg is sent and socket is closed"];
1334
packet_baddata_passive(suite) ->
1337
packet_baddata_passive(Config) when is_list(Config) ->
1338
ClientOpts = ?config(client_opts, Config),
1339
ServerOpts = ?config(server_opts, Config),
1340
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1342
Data = list_to_binary(lists:duplicate(100, "1234567890")),
1344
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1346
{mfa, {?MODULE, send_incomplete ,[Data, 1]}},
1347
{options, ServerOpts}]),
1348
Port = ssl_test_lib:inet_port(Server),
1349
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1352
{mfa, {?MODULE, passive_recv_packet,
1354
{options, [{active, false},
1359
{Client, {other, {error, {invalid_packet, _}},{error,closed}, 1}} -> ok;
1361
test_server:fail({unexpected, Unexpected})
1364
ssl_test_lib:close(Server),
1365
ssl_test_lib:close(Client).
1366
%%--------------------------------------------------------------------
1368
packet_size_active(doc) ->
1369
["Test that if a packet of size larger than
1370
packet_size arrives error msg is sent and socket is closed"];
1372
packet_size_active(suite) ->
1375
packet_size_active(Config) when is_list(Config) ->
1376
ClientOpts = ?config(client_opts, Config),
1377
ServerOpts = ?config(server_opts, Config),
1378
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1380
Data = list_to_binary(lists:duplicate(100, "1234567890")),
1382
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1384
{mfa, {?MODULE, send_incomplete ,[Data, 1]}},
1385
{options, ServerOpts}]),
1386
Port = ssl_test_lib:inet_port(Server),
1387
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1390
{mfa, {?MODULE, active_packet, [Data, 1]}},
1391
{options, [{active, true},
1392
{packet, 4}, {packet_size, 10} |
1395
{Client, {other, {ssl_error, _Socket,
1396
{invalid_packet, _}},{error,closed},1}} -> ok;
1398
test_server:fail({unexpected, Unexpected})
1401
ssl_test_lib:close(Server),
1402
ssl_test_lib:close(Client).
1403
%%--------------------------------------------------------------------
1405
packet_size_passive(doc) ->
1406
["Test that if a packet of size larger
1407
than packet_size arrives error msg is sent and socket is closed"];
1408
packet_size_passive(suite) -> [];
1410
packet_size_passive(Config) when is_list(Config) ->
1411
ClientOpts = ?config(client_opts, Config),
1412
ServerOpts = ?config(server_opts, Config),
1413
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1415
Data = list_to_binary(lists:duplicate(100, "1234567890")),
1417
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1419
{mfa, {?MODULE, send_incomplete ,[Data, 1]}},
1420
{options, ServerOpts}]),
1421
Port = ssl_test_lib:inet_port(Server),
1422
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1425
{mfa, {?MODULE, passive_recv_packet,
1427
{options, [{active, false},
1428
{packet, 4}, {packet_size, 30} |
1431
{Client, {other, {error, {invalid_packet, _}},{error,closed},1}} -> ok;
1433
test_server:fail({unexpected, Unexpected})
1436
ssl_test_lib:close(Server),
1437
ssl_test_lib:close(Client).
1439
%%--------------------------------------------------------------------
1440
packet_cdr_decode(doc) ->
1441
["Test setting the packet option {packet, cdr}, {mode, binary}"];
1442
packet_cdr_decode(suite) ->
1444
packet_cdr_decode(Config) when is_list(Config) ->
1445
ClientOpts = ?config(client_opts, Config),
1446
ServerOpts = ?config(server_opts, Config),
1447
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1449
%% A valid cdr packet
1450
Data = <<71,73,79,80,1,2,2,1,0,0,0,41,0,0,0,0,0,0,0,0,0,0,0,1,78,
1451
69,79,0,0,0,0,2,0,10,0,0,0,0,0,0,0,0,0,18,0,0,0,0,0,0,0,4,49>>,
1453
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1455
{mfa, {?MODULE, server_packet_decode,
1457
{options, [{active, true}, binary,
1458
{packet, cdr}|ServerOpts]}]),
1460
Port = ssl_test_lib:inet_port(Server),
1461
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1464
{mfa, {?MODULE, client_packet_decode,
1466
{options, [{active, true}, {packet, cdr},
1467
binary | ClientOpts]}]),
1469
ssl_test_lib:check_result(Server, ok, Client, ok),
1471
ssl_test_lib:close(Server),
1472
ssl_test_lib:close(Client).
1474
%%--------------------------------------------------------------------
1475
packet_cdr_decode_list(doc) ->
1476
["Test setting the packet option {packet, cdr} {mode, list}"];
1477
packet_cdr_decode_list(suite) ->
1479
packet_cdr_decode_list(Config) when is_list(Config) ->
1480
ClientOpts = ?config(client_opts, Config),
1481
ServerOpts = ?config(server_opts, Config),
1482
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1484
%% A valid cdr packet
1485
Data = [71,73,79,80,1,2,2,1,0,0,0,41,0,0,0,0,0,0,0,0,0,0,0,1,78,
1486
69,79,0,0,0,0,2,0,10,0,0,0,0,0,0,0,0,0,18,0,0,0,0,0,0,0,4,49],
1488
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1490
{mfa, {?MODULE, server_packet_decode,
1492
{options, [{active, true}, list,
1493
{packet, cdr}|ServerOpts]}]),
1495
Port = ssl_test_lib:inet_port(Server),
1496
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1499
{mfa, {?MODULE, client_packet_decode,
1501
{options, [{active, true}, {packet, cdr},
1502
list | ClientOpts]}]),
1504
ssl_test_lib:check_result(Server, ok, Client, ok),
1506
ssl_test_lib:close(Server),
1507
ssl_test_lib:close(Client).
1509
%%--------------------------------------------------------------------
1510
packet_http_decode(doc) ->
1511
["Test setting the packet option {packet, http} {mode, binary} "
1512
"(Body will be binary http strings are lists)"];
1513
packet_http_decode(suite) ->
1516
packet_http_decode(Config) when is_list(Config) ->
1517
ClientOpts = ?config(client_opts, Config),
1518
ServerOpts = ?config(server_opts, Config),
1519
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1521
Request = "GET / HTTP/1.1\r\n"
1522
"host: www.example.com\r\n"
1523
"user-agent: HttpTester\r\n"
1525
Response = "HTTP/1.1 200 OK\r\n"
1529
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1531
{mfa, {?MODULE, server_http_decode,
1533
{options, [{active, true},binary,
1534
{packet, http} | ServerOpts]}]),
1536
Port = ssl_test_lib:inet_port(Server),
1537
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1540
{mfa, {?MODULE, client_http_decode,
1542
{options, [{active, true}, binary,
1546
ssl_test_lib:check_result(Server, ok, Client, ok),
1548
ssl_test_lib:close(Server),
1549
ssl_test_lib:close(Client).
1552
server_http_decode(Socket, HttpResponse) ->
1553
assert_packet_opt(Socket, http),
1555
{ssl, Socket, {http_request, 'GET', _, {1,1}}} -> ok;
1556
Other1 -> exit({?LINE, Other1})
1558
assert_packet_opt(Socket, http),
1560
{ssl, Socket, {http_header, _, 'Host', _, "www.example.com"}} -> ok;
1561
Other2 -> exit({?LINE, Other2})
1563
assert_packet_opt(Socket, http),
1565
{ssl, Socket, {http_header, _, 'User-Agent', _, "HttpTester"}} -> ok;
1566
Other3 -> exit({?LINE, Other3})
1568
assert_packet_opt(Socket, http),
1570
{ssl, Socket, http_eoh} -> ok;
1571
Other4 -> exit({?LINE, Other4})
1573
assert_packet_opt(Socket, http),
1574
ok = ssl:send(Socket, HttpResponse),
1577
client_http_decode(Socket, HttpRequest) ->
1578
ok = ssl:send(Socket, HttpRequest),
1580
{ssl, Socket, {http_response, {1,1}, 200, "OK"}} -> ok;
1581
Other1 -> exit({?LINE, Other1})
1584
{ssl, Socket, http_eoh} -> ok;
1585
Other2 -> exit({?LINE, Other2})
1587
ok = ssl:setopts(Socket, [{packet, 0}]),
1589
{ssl, Socket, <<"Hello!">>} -> ok;
1590
Other3 -> exit({?LINE, Other3})
1594
%%--------------------------------------------------------------------
1595
packet_http_decode_list(doc) ->
1596
["Test setting the packet option {packet, http}, {mode, list}"
1597
"(Body will be litst too)"];
1598
packet_http_decode_list(suite) ->
1600
packet_http_decode_list(Config) when is_list(Config) ->
1601
ClientOpts = ?config(client_opts, Config),
1602
ServerOpts = ?config(server_opts, Config),
1603
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1605
Request = "GET / HTTP/1.1\r\n"
1606
"host: www.example.com\r\n"
1607
"user-agent: HttpTester\r\n"
1609
Response = "HTTP/1.1 200 OK\r\n"
1613
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1615
{mfa, {?MODULE, server_http_decode,
1617
{options, [{active, true}, binary,
1621
Port = ssl_test_lib:inet_port(Server),
1622
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1625
{mfa, {?MODULE, client_http_decode_list,
1627
{options, [{active, true}, list,
1631
ssl_test_lib:check_result(Server, ok, Client, ok),
1633
ssl_test_lib:close(Server),
1634
ssl_test_lib:close(Client).
1637
client_http_decode_list(Socket, HttpRequest) ->
1638
ok = ssl:send(Socket, HttpRequest),
1640
{ssl, Socket, {http_response, {1,1}, 200, "OK"}} -> ok;
1641
Other1 -> exit({?LINE, Other1})
1644
{ssl, Socket, http_eoh} -> ok;
1645
Other2 -> exit({?LINE, Other2})
1647
ok = ssl:setopts(Socket, [{packet, 0}]),
1649
{ssl, Socket, "Hello!"} -> ok;
1650
Other3 -> exit({?LINE, Other3})
1654
%%--------------------------------------------------------------------
1655
packet_http_bin_decode_multi(doc) ->
1656
["Test setting the packet option {packet, http_bin} with multiple requests"];
1657
packet_http_bin_decode_multi(suite) ->
1660
packet_http_bin_decode_multi(Config) when is_list(Config) ->
1661
ClientOpts = ?config(client_opts, Config),
1662
ServerOpts = ?config(server_opts, Config),
1663
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1665
Request = <<"GET / HTTP/1.1\r\n"
1666
"host: www.example.com\r\n"
1667
"user-agent: HttpTester\r\n"
1669
Response = <<"HTTP/1.1 200 OK\r\n"
1674
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1676
{mfa, {?MODULE, server_http_bin_decode,
1677
[Response, NumMsgs]}},
1678
{options, [{active, true}, binary,
1679
{packet, http_bin} |
1682
Port = ssl_test_lib:inet_port(Server),
1683
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1686
{mfa, {?MODULE, client_http_bin_decode,
1687
[Request, NumMsgs]}},
1688
{options, [{active, true}, binary,
1689
{packet, http_bin} |
1692
ssl_test_lib:check_result(Server, ok, Client, ok),
1694
ssl_test_lib:close(Server),
1695
ssl_test_lib:close(Client).
1698
server_http_bin_decode(Socket, HttpResponse, Count) when Count > 0 ->
1699
assert_packet_opt(Socket, http_bin),
1701
{ssl, Socket, {http_request, 'GET', _, {1,1}}} -> ok;
1702
Other1 -> exit({?LINE, Other1})
1704
assert_packet_opt(Socket, http_bin),
1706
{ssl, Socket, {http_header, _, 'Host', _, <<"www.example.com">>}} -> ok;
1707
Other2 -> exit({?LINE, Other2})
1709
assert_packet_opt(Socket, http_bin),
1711
{ssl, Socket, {http_header, _, 'User-Agent', _, <<"HttpTester">>}} -> ok;
1712
Other3 -> exit({?LINE, Other3})
1714
assert_packet_opt(Socket, http_bin),
1716
{ssl, Socket, http_eoh} -> ok;
1717
Other4 -> exit({?LINE, Other4})
1719
assert_packet_opt(Socket, http_bin),
1720
ok = ssl:send(Socket, HttpResponse),
1721
server_http_bin_decode(Socket, HttpResponse, Count - 1);
1722
server_http_bin_decode(_, _, _) ->
1725
client_http_bin_decode(Socket, HttpRequest, Count) when Count > 0 ->
1726
ok = ssl:send(Socket, HttpRequest),
1728
{ssl, Socket, {http_response, {1,1}, 200, <<"OK">>}} -> ok;
1729
Other1 -> exit({?LINE, Other1})
1732
{ssl, Socket, http_eoh} -> ok;
1733
Other2 -> exit({?LINE, Other2})
1735
ok = ssl:setopts(Socket, [{packet, 0}]),
1737
{ssl, Socket, <<"Hello!">>} -> ok;
1738
Other3 -> exit({?LINE, Other3})
1740
ok = ssl:setopts(Socket, [{packet, http_bin}]),
1741
client_http_bin_decode(Socket, HttpRequest, Count - 1);
1742
client_http_bin_decode(_, _, _) ->
1745
%%--------------------------------------------------------------------
1746
packet_http_error_passive(doc) ->
1747
["Test setting the packet option {packet, http}, {active, false}"
1748
" with a incorrect http header." ];
1749
packet_http_error_passive(suite) ->
1751
packet_http_error_passive(Config) when is_list(Config) ->
1752
ClientOpts = ?config(client_opts, Config),
1753
ServerOpts = ?config(server_opts, Config),
1754
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1756
Request = "GET / HTTP/1.1\r\n"
1757
"host: www.example.com\r\n"
1758
"user-agent HttpTester\r\n"
1760
Response = "HTTP/1.1 200 OK\r\n"
1764
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1766
{mfa, {?MODULE, server_http_decode_error,
1768
{options, [{active, false}, binary,
1772
Port = ssl_test_lib:inet_port(Server),
1773
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1776
{mfa, {?MODULE, client_http_decode_list,
1778
{options, [{active, true}, list,
1782
ssl_test_lib:check_result(Server, ok, Client, ok),
1784
ssl_test_lib:close(Server),
1785
ssl_test_lib:close(Client).
1788
server_http_decode_error(Socket, HttpResponse) ->
1789
assert_packet_opt(Socket, http),
1791
{ok, {http_request, 'GET', _, {1,1}}} = ssl:recv(Socket, 0),
1793
assert_packet_opt(Socket, http),
1795
{ok, {http_header, _, 'Host', _, "www.example.com"}} = ssl:recv(Socket, 0),
1796
assert_packet_opt(Socket, http),
1798
{ok, {http_error, _}} = ssl:recv(Socket, 0),
1800
assert_packet_opt(Socket, http),
1802
{ok, http_eoh} = ssl:recv(Socket, 0),
1804
assert_packet_opt(Socket, http),
1805
ok = ssl:send(Socket, HttpResponse),
1809
%%--------------------------------------------------------------------
1810
packet_line_decode(doc) ->
1811
["Test setting the packet option {packet, line}, {mode, binary}"];
1812
packet_line_decode(suite) ->
1814
packet_line_decode(Config) when is_list(Config) ->
1815
ClientOpts = ?config(client_opts, Config),
1816
ServerOpts = ?config(server_opts, Config),
1817
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1819
Data = list_to_binary(lists:flatten(io_lib:format("Line ends here.~n"
1820
"Now it is a new line.~n",
1823
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1825
{mfa, {?MODULE, server_line_packet_decode,
1827
{options, [{active, true}, binary,
1828
{packet, line}|ServerOpts]}]),
1830
Port = ssl_test_lib:inet_port(Server),
1831
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1834
{mfa, {?MODULE, client_line_packet_decode,
1836
{options, [{active, true},
1838
binary | ClientOpts]}]),
1840
ssl_test_lib:check_result(Server, ok, Client, ok),
1842
ssl_test_lib:close(Server),
1843
ssl_test_lib:close(Client).
1845
%%--------------------------------------------------------------------
1847
packet_line_decode_list(doc) ->
1848
["Test setting the packet option {packet, line}, {mode, list}"];
1849
packet_line_decode_list(suite) ->
1851
packet_line_decode_list(Config) when is_list(Config) ->
1852
ClientOpts = ?config(client_opts, Config),
1853
ServerOpts = ?config(server_opts, Config),
1854
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1856
Data = lists:flatten(io_lib:format("Line ends here.~n"
1857
"Now it is a new line.~n", [])),
1859
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1862
server_line_packet_decode,
1864
{options, [{active, true}, list,
1865
{packet, line}|ServerOpts]}]),
1867
Port = ssl_test_lib:inet_port(Server),
1868
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1872
client_line_packet_decode,
1874
{options, [{active, true},
1876
list | ClientOpts]}]),
1878
ssl_test_lib:check_result(Server, ok, Client, ok),
1880
ssl_test_lib:close(Server),
1881
ssl_test_lib:close(Client).
1884
%%--------------------------------------------------------------------
1886
packet_asn1_decode(doc) ->
1887
["Test setting the packet option {packet, asn1}"];
1888
packet_asn1_decode(suite) ->
1890
packet_asn1_decode(Config) when is_list(Config) ->
1891
ClientOpts = ?config(client_opts, Config),
1892
ServerOpts = ?config(server_opts, Config),
1893
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1895
File = proplists:get_value(certfile, ServerOpts),
1897
%% A valid asn1 BER packet (DER is stricter BER)
1898
[{'Certificate', Data, _}] = ssl_test_lib:pem_to_der(File),
1900
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1902
{mfa, {?MODULE, server_packet_decode,
1904
{options, [{active, true}, binary,
1905
{packet, asn1}|ServerOpts]}]),
1907
Port = ssl_test_lib:inet_port(Server),
1908
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1911
{mfa, {?MODULE, client_packet_decode,
1913
{options, [{active, true}, {packet, asn1},
1914
binary | ClientOpts]}]),
1916
ssl_test_lib:check_result(Server, ok, Client, ok),
1918
ssl_test_lib:close(Server),
1919
ssl_test_lib:close(Client).
1921
%%--------------------------------------------------------------------
1922
packet_asn1_decode_list(doc) ->
1923
["Test setting the packet option {packet, asn1}"];
1924
packet_asn1_decode_list(suite) ->
1926
packet_asn1_decode_list(Config) when is_list(Config) ->
1927
ClientOpts = ?config(client_opts, Config),
1928
ServerOpts = ?config(server_opts, Config),
1929
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1931
File = proplists:get_value(certfile, ServerOpts),
1933
%% A valid asn1 BER packet (DER is stricter BER)
1934
[{'Certificate', BinData, _}] = ssl_test_lib:pem_to_der(File),
1936
Data = binary_to_list(BinData),
1938
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1940
{mfa, {?MODULE, server_packet_decode,
1942
{options, [{active, true}, list,
1943
{packet, asn1}|ServerOpts]}]),
1945
Port = ssl_test_lib:inet_port(Server),
1946
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1949
{mfa, {?MODULE, client_packet_decode,
1951
{options, [{active, true}, {packet, asn1},
1952
list | ClientOpts]}]),
1954
ssl_test_lib:check_result(Server, ok, Client, ok),
1956
ssl_test_lib:close(Server),
1957
ssl_test_lib:close(Client).
1959
%%--------------------------------------------------------------------
1960
packet_tpkt_decode(doc) ->
1961
["Test setting the packet option {packet, tpkt}"];
1962
packet_tpkt_decode(suite) ->
1964
packet_tpkt_decode(Config) when is_list(Config) ->
1965
ClientOpts = ?config(client_opts, Config),
1966
ServerOpts = ?config(server_opts, Config),
1967
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
1969
Data = list_to_binary(add_tpkt_header("TPKT data")),
1972
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
1974
{mfa, {?MODULE, server_packet_decode,
1976
{options, [{active, true}, binary,
1977
{packet, tpkt}|ServerOpts]}]),
1979
Port = ssl_test_lib:inet_port(Server),
1980
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
1983
{mfa, {?MODULE, client_packet_decode,
1985
{options, [{active, true}, {packet, tpkt},
1986
binary | ClientOpts]}]),
1988
ssl_test_lib:check_result(Server, ok, Client, ok),
1990
ssl_test_lib:close(Server),
1991
ssl_test_lib:close(Client).
1992
%%--------------------------------------------------------------------
1993
packet_tpkt_decode_list(doc) ->
1994
["Test setting the packet option {packet, tpkt}"];
1995
packet_tpkt_decode_list(suite) ->
1997
packet_tpkt_decode_list(Config) when is_list(Config) ->
1998
ClientOpts = ?config(client_opts, Config),
1999
ServerOpts = ?config(server_opts, Config),
2000
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2002
Data = binary_to_list(list_to_binary(add_tpkt_header("TPKT data"))),
2004
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2006
{mfa, {?MODULE, server_packet_decode,
2008
{options, [{active, true}, list,
2009
{packet, tpkt}|ServerOpts]}]),
2011
Port = ssl_test_lib:inet_port(Server),
2012
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2015
{mfa, {?MODULE, client_packet_decode,
2017
{options, [{active, true}, {packet, tpkt},
2018
list | ClientOpts]}]),
2020
ssl_test_lib:check_result(Server, ok, Client, ok),
2022
ssl_test_lib:close(Server),
2023
ssl_test_lib:close(Client).
2025
%%--------------------------------------------------------------------
2027
%% packet_fcgi_decode(doc) ->
2028
%% ["Test setting the packet option {packet, fcgi}"];
2029
%% packet_fcgi_decode(suite) ->
2031
%% packet_fcgi_decode(Config) when is_list(Config) ->
2032
%% ClientOpts = ?config(client_opts, Config),
2033
%% ServerOpts = ?config(server_opts, Config),
2034
%% {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2038
%% Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2040
%% {mfa, {?MODULE, server_packet_decode,
2041
%% [Data0, Data1]}},
2042
%% {options, [{active, true}, binary,
2043
%% {packet, fcgi}|ServerOpts]}]),
2045
%% Port = ssl_test_lib:inet_port(Server),
2046
%% Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2047
%% {host, Hostname},
2049
%% {mfa, {?MODULE, client_packet_decode,
2050
%% [Data0, Data1]}},
2051
%% {options, [{active, true}, {packet, fcgi},
2052
%% binary | ClientOpts]}]),
2054
%% ssl_test_lib:check_result(Server, ok, Client, ok),
2056
%% ssl_test_lib:close(Server),
2057
%% ssl_test_lib:close(Client).
2060
%%--------------------------------------------------------------------
2062
packet_sunrm_decode(doc) ->
2063
["Test setting the packet option {packet, sunrm}"];
2064
packet_sunrm_decode(suite) ->
2066
packet_sunrm_decode(Config) when is_list(Config) ->
2067
ClientOpts = ?config(client_opts, Config),
2068
ServerOpts = ?config(server_opts, Config),
2069
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2071
Data = <<11:32, "Hello world">>,
2073
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2075
{mfa, {?MODULE, server_packet_decode,
2077
{options, [{active, true}, binary,
2078
{packet, sunrm}|ServerOpts]}]),
2080
Port = ssl_test_lib:inet_port(Server),
2081
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2084
{mfa, {?MODULE, client_packet_decode,
2086
{options, [{active, true}, {packet, sunrm},
2087
binary | ClientOpts]}]),
2089
ssl_test_lib:check_result(Server, ok, Client, ok),
2091
ssl_test_lib:close(Server),
2092
ssl_test_lib:close(Client).
2094
%%--------------------------------------------------------------------
2095
packet_sunrm_decode_list(doc) ->
2096
["Test setting the packet option {packet, sunrm}"];
2097
packet_sunrm_decode_list(suite) ->
2099
packet_sunrm_decode_list(Config) when is_list(Config) ->
2100
ClientOpts = ?config(client_opts, Config),
2101
ServerOpts = ?config(server_opts, Config),
2102
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2104
Data = binary_to_list(list_to_binary([<<11:32>>, "Hello world"])),
2106
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2108
{mfa, {?MODULE, server_packet_decode,
2110
{options, [{active, true}, list,
2111
{packet, sunrm}|ServerOpts]}]),
2113
Port = ssl_test_lib:inet_port(Server),
2114
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2117
{mfa, {?MODULE, client_packet_decode,
2119
{options, [{active, true}, {packet, sunrm},
2120
list | ClientOpts]}]),
2122
ssl_test_lib:check_result(Server, ok, Client, ok),
2124
ssl_test_lib:close(Server),
2125
ssl_test_lib:close(Client).
2126
%%--------------------------------------------------------------------
2128
header_decode_one_byte(doc) ->
2129
["Test setting the packet option {header, 1}"];
2130
header_decode_one_byte(suite) ->
2132
header_decode_one_byte(Config) when is_list(Config) ->
2133
ClientOpts = ?config(client_opts, Config),
2134
ServerOpts = ?config(server_opts, Config),
2135
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2137
Data = <<11:8, "Hello world">>,
2139
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2141
{mfa, {?MODULE, server_header_decode,
2142
[Data, [11 | <<"Hello world">>]]}},
2143
{options, [{active, true}, binary,
2144
{header,1}|ServerOpts]}]),
2146
Port = ssl_test_lib:inet_port(Server),
2147
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2150
{mfa, {?MODULE, client_header_decode,
2151
[Data, [11 | <<"Hello world">> ]]}},
2152
{options, [{active, true}, {header, 1},
2153
binary | ClientOpts]}]),
2155
ssl_test_lib:check_result(Server, ok, Client, ok),
2157
ssl_test_lib:close(Server),
2158
ssl_test_lib:close(Client).
2160
%%--------------------------------------------------------------------
2162
header_decode_two_bytes(doc) ->
2163
["Test setting the packet option {header, 2}"];
2164
header_decode_two_bytes(suite) ->
2166
header_decode_two_bytes(Config) when is_list(Config) ->
2167
ClientOpts = ?config(client_opts, Config),
2168
ServerOpts = ?config(server_opts, Config),
2169
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2171
Data = <<11:8, "Hello world">>,
2173
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2175
{mfa, {?MODULE, server_header_decode,
2176
[Data, [11, $H | <<"ello world">> ]]}},
2177
{options, [{active, true}, binary,
2178
{header,2}|ServerOpts]}]),
2180
Port = ssl_test_lib:inet_port(Server),
2181
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2184
{mfa, {?MODULE, client_header_decode,
2185
[Data, [11, $H | <<"ello world">> ]]}},
2186
{options, [{active, true}, {header, 2},
2187
binary | ClientOpts]}]),
2189
ssl_test_lib:check_result(Server, ok, Client, ok),
2191
ssl_test_lib:close(Server),
2192
ssl_test_lib:close(Client).
2195
%%--------------------------------------------------------------------
2197
header_decode_two_bytes_two_sent(doc) ->
2198
["Test setting the packet option {header, 2} and sending on byte"];
2199
header_decode_two_bytes_two_sent(suite) ->
2201
header_decode_two_bytes_two_sent(Config) when is_list(Config) ->
2202
ClientOpts = ?config(client_opts, Config),
2203
ServerOpts = ?config(server_opts, Config),
2204
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2208
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2210
{mfa, {?MODULE, server_header_decode,
2211
[Data, [$H, $e | <<>> ]]}},
2212
{options, [{active, true}, binary,
2213
{header,2}|ServerOpts]}]),
2215
Port = ssl_test_lib:inet_port(Server),
2216
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2219
{mfa, {?MODULE, client_header_decode,
2220
[Data, [$H, $e | <<>> ]]}},
2221
{options, [{active, true}, {header, 2},
2222
binary | ClientOpts]}]),
2224
ssl_test_lib:check_result(Server, ok, Client, ok),
2226
ssl_test_lib:close(Server),
2227
ssl_test_lib:close(Client).
2230
%%--------------------------------------------------------------------
2232
header_decode_two_bytes_one_sent(doc) ->
2233
["Test setting the packet option {header, 2} and sending on byte"];
2234
header_decode_two_bytes_one_sent(suite) ->
2236
header_decode_two_bytes_one_sent(Config) when is_list(Config) ->
2237
ClientOpts = ?config(client_opts, Config),
2238
ServerOpts = ?config(server_opts, Config),
2239
{ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
2243
Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0},
2245
{mfa, {?MODULE, server_header_decode,
2247
{options, [{active, true}, binary,
2248
{header,2}|ServerOpts]}]),
2250
Port = ssl_test_lib:inet_port(Server),
2251
Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port},
2254
{mfa, {?MODULE, client_header_decode,
2256
{options, [{active, true}, {header, 2},
2257
binary | ClientOpts]}]),
2259
ssl_test_lib:check_result(Server, ok, Client, ok),
2261
ssl_test_lib:close(Server),
2262
ssl_test_lib:close(Client).
2265
%%--------------------------------------------------------------------
2266
%% Internal functions
2268
send_raw(Socket,_, 0) ->
2269
ssl:send(Socket, <<>>),
2271
send_raw(Socket, Data, N) ->
2272
ssl:send(Socket, Data),
2273
send_raw(Socket, Data, N-1).
2275
passive_raw(Socket, _, 0) ->
2276
{error, timeout} = ssl:recv(Socket, 0, 500),
2278
passive_raw(Socket, Data, N) ->
2279
Length = length(Data),
2280
{ok, Data} = ssl:recv(Socket, Length),
2281
passive_raw(Socket, Data, N-1).
2283
passive_recv_packet(Socket, _, 0) ->
2284
case ssl:recv(Socket, 0) of
2286
{error, timeout} = ssl:recv(Socket, 0, 500),
2289
{other, Other, ssl:session_info(Socket), 0}
2291
passive_recv_packet(Socket, Data, N) ->
2292
case ssl:recv(Socket, 0) of
2294
passive_recv_packet(Socket, Data, N-1);
2296
{other, Other, ssl:session_info(Socket), N}
2299
send(Socket,_, 0) ->
2300
ssl:send(Socket, <<>>),
2302
send(Socket, Data, N) ->
2303
case ssl:send(Socket, [Data]) of
2305
send(Socket, Data, N-1);
2310
send_incomplete(Socket, Data, N) ->
2311
send_incomplete(Socket, Data, N, <<>>).
2312
send_incomplete(Socket, _Data, 0, Prev) ->
2313
ssl:send(Socket, Prev),
2314
ssl:send(Socket, [?uint32(0)]),
2316
send_incomplete(Socket, Data, N, Prev) ->
2317
Length = size(Data),
2318
<<Part1:42/binary, Rest/binary>> = Data,
2319
ssl:send(Socket, [Prev, ?uint32(Length), Part1]),
2320
send_incomplete(Socket, Data, N-1, Rest).
2322
active_once_raw(Socket, Data, N) ->
2323
active_once_raw(Socket, Data, N, []).
2325
active_once_raw(_, _, 0, _) ->
2327
active_once_raw(Socket, Data, N, Acc) ->
2329
{ssl, Socket, Data} ->
2330
ssl:setopts(Socket, [{active, once}]),
2331
active_once_raw(Socket, Data, N-1, []);
2332
{ssl, Socket, Other} ->
2333
case Acc ++ Other of
2335
ssl:setopts(Socket, [{active, once}]),
2336
active_once_raw(Socket, Data, N-1, []);
2338
ssl:setopts(Socket, [{active, once}]),
2339
active_once_raw(Socket, Data, N, NewAcc)
2343
active_once_packet(Socket,_, 0) ->
2345
{ssl, Socket, []} ->
2347
{ssl, Socket, Other} ->
2348
{other, Other, ssl:session_info(Socket), 0}
2350
active_once_packet(Socket, Data, N) ->
2352
{ssl, Socket, Data} ->
2355
ssl:setopts(Socket, [{active, once}]),
2356
active_once_packet(Socket, Data, N-1).
2358
active_raw(Socket, Data, N) ->
2359
active_raw(Socket, Data, N, []).
2361
active_raw(_Socket, _, 0, _) ->
2363
active_raw(Socket, Data, N, Acc) ->
2365
{ssl, Socket, Data} ->
2366
active_raw(Socket, Data, N-1, []);
2367
{ssl, Socket, Other} ->
2368
case Acc ++ Other of
2370
active_raw(Socket, Data, N-1, []);
2372
active_raw(Socket, Data, NewAcc)
2376
active_packet(Socket, _, 0) ->
2378
{ssl, Socket, []} ->
2381
{other, Other, ssl:session_info(Socket), 0}
2383
active_packet(Socket, Data, N) ->
2385
{ssl, Socket, Data} ->
2386
active_packet(Socket, Data, N -1);
2388
{other, Other, ssl:session_info(Socket),N}
2391
assert_packet_opt(Socket, Type) ->
2392
{ok, [{packet, Type}]} = ssl:getopts(Socket, [packet]).
2394
server_packet_decode(Socket, Packet) ->
2396
{ssl, Socket, Packet} -> ok;
2397
Other1 -> exit({?LINE, Other1})
2399
ok = ssl:send(Socket, Packet),
2401
{ssl, Socket, Packet} -> ok;
2402
Other2 -> exit({?LINE, Other2})
2404
ok = ssl:send(Socket, Packet).
2406
client_packet_decode(Socket, Packet) when is_binary(Packet)->
2407
<<P1:10/binary, P2/binary>> = Packet,
2408
client_packet_decode(Socket, P1, P2, Packet);
2409
client_packet_decode(Socket, [Head | Tail] = Packet) ->
2410
client_packet_decode(Socket, [Head], Tail, Packet).
2412
client_packet_decode(Socket, P1, P2, Packet) ->
2413
test_server:format("Packet: ~p ~n", [Packet]),
2414
ok = ssl:send(Socket, P1),
2415
ok = ssl:send(Socket, P2),
2417
{ssl, Socket, Packet} -> ok;
2418
Other1 -> exit({?LINE, Other1})
2420
ok = ssl:send(Socket, Packet),
2422
{ssl, Socket, Packet} -> ok;
2423
Other2 -> exit({?LINE, Other2})
2426
server_header_decode(Socket, Packet, Result) ->
2428
{ssl, Socket, Result} -> ok;
2429
Other1 -> exit({?LINE, Other1})
2431
ok = ssl:send(Socket, Packet),
2433
{ssl, Socket, Result} -> ok;
2434
Other2 -> exit({?LINE, Other2})
2436
ok = ssl:send(Socket, Packet).
2438
client_header_decode(Socket, Packet, Result) ->
2439
ok = ssl:send(Socket, Packet),
2441
{ssl, Socket, Result} -> ok;
2442
Other1 -> exit({?LINE, Other1})
2444
ok = ssl:send(Socket, Packet),
2446
{ssl, Socket, Result} -> ok;
2447
Other2 -> exit({?LINE, Other2})
2450
server_line_packet_decode(Socket, Packet) when is_binary(Packet) ->
2451
[L1, L2] = string:tokens(binary_to_list(Packet), "\n"),
2452
server_line_packet_decode(Socket, list_to_binary(L1 ++ "\n"), list_to_binary(L2 ++ "\n"), Packet);
2453
server_line_packet_decode(Socket, Packet) ->
2454
[L1, L2] = string:tokens(Packet, "\n"),
2455
server_line_packet_decode(Socket, L1 ++ "\n", L2 ++ "\n", Packet).
2457
server_line_packet_decode(Socket, L1, L2, Packet) ->
2459
{ssl, Socket, L1} -> ok;
2460
Other1 -> exit({?LINE, Other1})
2463
{ssl, Socket, L2} -> ok;
2464
Other2 -> exit({?LINE, Other2})
2466
ok = ssl:send(Socket, Packet).
2468
client_line_packet_decode(Socket, Packet) when is_binary(Packet)->
2469
<<P1:10/binary, P2/binary>> = Packet,
2470
[L1, L2] = string:tokens(binary_to_list(Packet), "\n"),
2471
client_line_packet_decode(Socket, P1, P2, list_to_binary(L1 ++ "\n"), list_to_binary(L2 ++ "\n"));
2472
client_line_packet_decode(Socket, [Head | Tail] = Packet) ->
2473
[L1, L2] = string:tokens(Packet, "\n"),
2474
client_line_packet_decode(Socket, [Head], Tail, L1 ++ "\n", L2 ++ "\n").
2476
client_line_packet_decode(Socket, P1, P2, L1, L2) ->
2477
ok = ssl:send(Socket, P1),
2478
ok = ssl:send(Socket, P2),
2480
{ssl, Socket, L1} -> ok;
2481
Other1 -> exit({?LINE, Other1})
2484
{ssl, Socket, L2} -> ok;
2485
Other2 -> exit({?LINE, Other2})
2488
add_tpkt_header(Data) when is_binary(Data) ->
2490
[3, 0, ((L) bsr 8) band 16#ff, (L) band 16#ff ,Data];
2491
add_tpkt_header(IOList) when is_list(IOList) ->
2492
Binary = list_to_binary(IOList),
2493
L = size(Binary) + 4,
2494
[3, 0, ((L) bsr 8) band 16#ff, (L) band 16#ff , Binary].
added
removed
lib/ssl/test/ssl_packet_SUITE.erl
