← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/megaco/examples/meas/megaco_codec_mstone_lib.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/megaco/examples/meas/megaco_codec_mstone_lib.erl
27
27
 
28
28
%% API
29
29
-export([start_flex_scanner/0, stop_flex_scanner/1,
30
 
         read_messages/1,
31
 
         expand_dirs/2,
 
30
         expanded_messages/2, expanded_messages/3, 
 
31
         set_default_sched_bind/0,
32
32
         display_os_info/0, 
33
33
         display_system_info/0, 
34
34
         display_alloc_info/0, 
68
68
 
69
69
%%----------------------------------------------------------------------
70
70
%% 
 
71
%% S c h e d u l e r   b i n d   t y p e
 
72
%% 
 
73
%%----------------------------------------------------------------------
 
74
 
 
75
set_default_sched_bind() ->
 
76
    (catch erlang:system_flag(scheduler_bind_type, default_bind)).
 
77
 
 
78
 
 
79
%%----------------------------------------------------------------------
 
80
%% 
71
81
%% D i s p l a y   O s   I n f o 
72
82
%% 
73
83
%%----------------------------------------------------------------------
95
105
%%----------------------------------------------------------------------
96
106
 
97
107
display_system_info() ->
98
 
    SysArch = string:strip(erlang:system_info(system_architecture),right,$\n),
99
 
    OtpRel  = otp_release(),
100
 
    SysVer  = string:strip(erlang:system_info(system_version),right,$\n),
101
 
    SysHT   = erlang:system_info(heap_type),
102
 
    SysGHSz = erlang:system_info(global_heaps_size),
103
 
    SysSMP  = erlang:system_info(smp_support),
104
 
    SysNumSched  = erlang:system_info(schedulers),
105
 
    SysProcLimit = erlang:system_info(process_limit),
106
 
    SysThreads   = erlang:system_info(threads),
107
 
    SysTPSz      = erlang:system_info(thread_pool_size),
 
108
    SysArch       = system_architecture(),
 
109
    OtpRel        = otp_release(),
 
110
    SysVer        = system_version(),
 
111
    SysHT         = heap_type(),
 
112
    SysGHSz       = global_heaps_size(),
 
113
    SysSMP        = smp_support(),
 
114
    SysNumSched   = schedulers(),
 
115
    SysProcLimit  = process_limit(),
 
116
    SysThreads    = threads(),
 
117
    SysTPSz       = thread_pool_size(),
 
118
    SchedBindings = scheduler_bindings(),
 
119
    SchedBindType = scheduler_bind_type(),
 
120
    CpuTopology   = cpu_topology(), 
108
121
    io:format("System architecture: ~s~n", [SysArch]),
109
122
    io:format("OTP release:         ~s~n", [OtpRel]),
110
123
    io:format("System version:      ~s~n", [SysVer]),
111
 
    io:format("Heap type:           ~w~n", [SysHT]),
112
 
    io:format("Global heap size:    ~w~n", [SysGHSz]),
113
 
    io:format("Thread support:      ~w~n", [SysThreads]),
114
 
    io:format("Thread pool size:    ~w~n", [SysTPSz]),
115
 
    io:format("SMP support:         ~w~n", [SysSMP]),
116
 
    io:format("Num schedulers:      ~w~n", [SysNumSched]),
117
 
    io:format("Process limit:       ~w~n", [SysProcLimit]),
 
124
    io:format("Heap type:           ~s~n", [SysHT]),
 
125
    io:format("Global heap size:    ~s~n", [SysGHSz]),
 
126
    io:format("Thread support:      ~s~n", [SysThreads]),
 
127
    io:format("Thread pool size:    ~s~n", [SysTPSz]),
 
128
    io:format("Process limit:       ~s~n", [SysProcLimit]),
 
129
    io:format("SMP support:         ~s~n", [SysSMP]),
 
130
    io:format("Num schedulers:      ~s~n", [SysNumSched]),
 
131
    io:format("Scheduler bindings:  ~s~n", [SchedBindings]),
 
132
    io:format("Scheduler bind type: ~s~n", [SchedBindType]),
 
133
    io:format("Cpu topology:        ~s~n", [CpuTopology]),
118
134
    ok.
119
135
 
120
136
 
 
137
system_architecture() ->
 
138
    string:strip(system_info(system_architecture, string),right,$\n).
 
139
 
121
140
otp_release() ->
122
 
    case (catch erlang:system_info(otp_release)) of
123
 
        R when is_list(R) ->
124
 
            R;
125
 
        _ ->
126
 
            "-"
 
141
    system_info(otp_release, string).
 
142
 
 
143
system_version() ->
 
144
    string:strip(system_info(system_version, string),right,$\n).
 
145
 
 
146
heap_type() ->
 
147
    system_info(heap_type, any).
 
148
 
 
149
global_heaps_size() ->
 
150
    system_info(global_heaps_size, any).
 
151
 
 
152
smp_support() ->
 
153
    system_info(smp_support, any).
 
154
 
 
155
schedulers() ->
 
156
    system_info(schedulers, any).
 
157
 
 
158
process_limit() ->
 
159
    system_info(process_limit, any).
 
160
 
 
161
threads() ->
 
162
    system_info(threads, any).
 
163
 
 
164
thread_pool_size() ->
 
165
    system_info(thread_pool_size, any).
 
166
 
 
167
scheduler_bindings() ->
 
168
    system_info(scheduler_bindings, any).
 
169
 
 
170
scheduler_bind_type() ->
 
171
    system_info(scheduler_bind_type, any).
 
172
 
 
173
cpu_topology() ->
 
174
    system_info(cpu_topology, any).
 
175
 
 
176
system_info(Tag, Type) ->
 
177
    case (catch erlang:system_info(Tag)) of
 
178
        {'EXIT', _} ->
 
179
            "-";
 
180
        Info when is_list(Info) andalso (Type =:= string) ->
 
181
            Info;
 
182
        Info ->
 
183
            lists:flatten(io_lib:format("~w", [Info]))
127
184
    end.
128
185
 
129
186
 
 
187
 
130
188
%%----------------------------------------------------------------------
131
189
%% 
132
190
%% D i s p l a y   A l l o c a t o r   I n f o 
239
297
 
240
298
%%----------------------------------------------------------------------
241
299
%% 
242
 
%% E x p a n d   D i r s
243
 
%% 
244
 
%%----------------------------------------------------------------------
245
 
 
246
 
expand_dirs(Dirs, DrvInclude) ->
247
 
    expand_dirs(Dirs, DrvInclude, []).
248
 
 
249
 
expand_dirs([], _, EDirs) ->
250
 
    lists:reverse(lists:flatten(EDirs));
251
 
expand_dirs([Dir|Dirs], DrvInclude, EDirs) when is_atom(Dir) ->
252
 
    EDir = expand_dir(atom_to_list(Dir), DrvInclude),
253
 
    expand_dirs(Dirs, DrvInclude, [EDir|EDirs]);
254
 
expand_dirs([Dir|Dirs], DrvInclude, EDirs) when is_list(Dir) ->
255
 
    EDir = expand_dir(Dir, DrvInclude),
256
 
    expand_dirs(Dirs, DrvInclude, [EDir|EDirs]).
257
 
 
258
 
expand_dir(Dir, flex) ->
259
 
    case Dir of
260
 
        "pretty" ->
261
 
            [{Dir, megaco_pretty_text_encoder, [flex_scanner]},
262
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]},
263
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]},
264
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]},
265
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]},
266
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]},
267
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]},
268
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]}];
269
 
        "compact" ->
270
 
            [{Dir, megaco_compact_text_encoder, [flex_scanner]},
271
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]},
272
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]},
273
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]},
274
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]},
275
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]},
276
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]},
277
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]}];
278
 
        "ber" ->
279
 
            [];
280
 
        "per" ->
281
 
            [];
282
 
        "erlang" ->
283
 
            [];
284
 
        Else ->
285
 
            error({invalid_codec, Else})
286
 
    end;
287
 
expand_dir(Dir, only_drv) ->
288
 
    case Dir of
289
 
        "pretty" ->
290
 
            [{Dir, megaco_pretty_text_encoder, [flex_scanner]},
291
 
             {Dir, megaco_pretty_text_encoder, [flex_scanner]}];
292
 
        "compact" ->
293
 
            [{Dir, megaco_compact_text_encoder, [flex_scanner]},
294
 
             {Dir, megaco_compact_text_encoder, [flex_scanner]}];
295
 
        "ber" ->
296
 
            [{Dir, megaco_ber_bin_encoder, [driver,native]},
297
 
             {Dir, megaco_ber_bin_encoder, [driver]},
298
 
             {Dir, megaco_ber_bin_encoder, [driver,native]},
299
 
             {Dir, megaco_ber_bin_encoder, [driver]}];
300
 
        "per" ->
301
 
            [{Dir, megaco_per_bin_encoder, [driver,native]},
302
 
             {Dir, megaco_per_bin_encoder, [native]},
303
 
             {Dir, megaco_per_bin_encoder, [driver,native]},
304
 
             {Dir, megaco_per_bin_encoder, [native]}];
305
 
        "erlang" ->
306
 
            Encoder = megaco_erl_dist_encoder,
307
 
            [
308
 
             {Dir, Encoder, [megaco_compressed,compressed]},
309
 
             {Dir, Encoder, [compressed]},
310
 
             {Dir, Encoder, [megaco_compressed,compressed]},
311
 
             {Dir, Encoder, [compressed]}
312
 
            ];
313
 
        Else ->
314
 
            error({invalid_codec, Else})
315
 
    end;
316
 
expand_dir(Dir, no_drv) ->
317
 
    case Dir of
318
 
        "pretty" ->
319
 
            [{Dir, megaco_pretty_text_encoder, []},
320
 
             {Dir, megaco_pretty_text_encoder, []}];
321
 
        "compact" ->
322
 
            [{Dir, megaco_compact_text_encoder, []},
323
 
             {Dir, megaco_compact_text_encoder, []}];
324
 
        "ber" ->
325
 
            [{Dir, megaco_ber_bin_encoder, [native]},
326
 
             {Dir, megaco_ber_bin_encoder, []},
327
 
             {Dir, megaco_ber_bin_encoder, [native]},
328
 
             {Dir, megaco_ber_bin_encoder, []}];
329
 
        "per" ->
330
 
            [{Dir, megaco_per_bin_encoder, [native]},
331
 
             {Dir, megaco_per_bin_encoder, []},
332
 
             {Dir, megaco_per_bin_encoder, [native]},
333
 
             {Dir, megaco_per_bin_encoder, []}];
334
 
        "erlang" ->
335
 
            Encoder = megaco_erl_dist_encoder,
336
 
            [
337
 
             {Dir, Encoder, [megaco_compressed]},
338
 
             {Dir, Encoder, []},
339
 
             {Dir, Encoder, [megaco_compressed]},
340
 
             {Dir, Encoder, []}
341
 
            ];
342
 
        Else ->
343
 
            error({invalid_codec, Else})
344
 
    end;
345
 
expand_dir(Dir, _) ->
346
 
    case Dir of
347
 
        "pretty" ->
348
 
            [{Dir, megaco_pretty_text_encoder, [flex_scanner]},
349
 
             {Dir, megaco_pretty_text_encoder, []}];
350
 
        "compact" ->
351
 
            [{Dir, megaco_compact_text_encoder, [flex_scanner]},
352
 
             {Dir, megaco_compact_text_encoder, []}];
353
 
        "ber" ->
354
 
            [{Dir, megaco_ber_bin_encoder, [driver,native]},
355
 
             {Dir, megaco_ber_bin_encoder, [native]},
356
 
             {Dir, megaco_ber_bin_encoder, [driver]},
357
 
             {Dir, megaco_ber_bin_encoder, []}];
358
 
        "per" ->
359
 
            [{Dir, megaco_per_bin_encoder, [driver,native]},
360
 
             {Dir, megaco_per_bin_encoder, [native]},
361
 
             {Dir, megaco_per_bin_encoder, [driver]},
362
 
             {Dir, megaco_per_bin_encoder, []}];
363
 
        "erlang" ->
364
 
            Encoder = megaco_erl_dist_encoder,
365
 
            [
366
 
             {Dir, Encoder, [megaco_compressed,compressed]},
367
 
             {Dir, Encoder, [compressed]},
368
 
             {Dir, Encoder, [megaco_compressed]},
369
 
             {Dir, Encoder, []}
370
 
            ];
371
 
        Else ->
372
 
            error({invalid_codec, Else})
373
 
    end.
374
 
 
375
 
 
376
 
%%----------------------------------------------------------------------
377
 
%% 
378
 
%% R e a d   M e s s a g e s
379
 
%% 
380
 
%%----------------------------------------------------------------------
381
 
 
382
 
read_messages(Dir) ->
383
 
    [read_message(Dir, File) || File <- read_files(Dir)].
384
 
 
385
 
read_message(Dir, FileName) ->
386
 
    File = filename:join([Dir, FileName]),
387
 
    case file:read_file_info(File) of
388
 
        {ok, #file_info{size = Sz, type = regular}} when Sz > 0 ->
389
 
            case file:read_file(File) of
390
 
                {ok, Msg} ->
391
 
                    Msg;
392
 
                Error ->
393
 
                    error({failed_reading_file, Error})
394
 
            end;
395
 
 
396
 
        {ok, #file_info{type = regular}} ->
397
 
            error({file_empty, FileName});
398
 
 
399
 
        {ok, #file_info{type = Type}} ->
400
 
            error({invalid_type, FileName, Type});
401
 
 
402
 
        {ok, Info} ->
403
 
            error({unexpected_file_info, FileName, Info});
404
 
 
405
 
        Error ->
406
 
            error({failed_reading_file_info, File, Error})
407
 
 
408
 
    end.
409
 
 
410
 
 
411
 
read_files(Dir) ->
412
 
    case file:list_dir(Dir) of
413
 
        {ok, Files} ->
414
 
            lists:sort(Files);
415
 
        Error ->
416
 
            error({failed_listing_dir, Dir, Error})
 
300
%% E x p a n d   M e s s a g e s
 
301
%% 
 
302
%%----------------------------------------------------------------------
 
303
 
 
304
expanded_messages(Codecs, DrvInclude) ->
 
305
    MessagePackage = time_test, 
 
306
    expanded_messages(MessagePackage, Codecs, DrvInclude).
 
307
 
 
308
expanded_messages(MessagePackage, Codecs, DrvInclude) ->
 
309
    ECodecs  = expand_codecs(Codecs, DrvInclude), 
 
310
    Messages = megaco_codec_transform:messages(MessagePackage), 
 
311
    expanded_messages2(ECodecs, Messages, []).
 
312
 
 
313
expanded_messages2([], _Messages, EMessages) ->
 
314
    lists:reverse(EMessages);
 
315
expanded_messages2([{Codec, Mod, Conf}|ECodecs], Messages, EMessages) ->
 
316
    case lists:keysearch(Codec, 1, Messages) of
 
317
        {value, {Codec, Msgs}} ->
 
318
            expanded_messages2(ECodecs, Messages, 
 
319
                               [{Codec, Mod, Conf, Msgs}|EMessages]);
 
320
        false ->
 
321
            exit({error, {no_such_codec_data, Codec}})
 
322
    end.
 
323
 
 
324
 
 
325
%%----------------------------------------------------------------------
 
326
%% 
 
327
%% E x p a n d   C o d e c s
 
328
%% 
 
329
%%----------------------------------------------------------------------
 
330
 
 
331
expand_codecs(Codecs, DrvInclude) ->
 
332
    expand_codecs(Codecs, DrvInclude, []).
 
333
 
 
334
expand_codecs([], _, ECodecs) ->
 
335
    lists:reverse(lists:flatten(ECodecs));
 
336
expand_codecs([Codec|Codecs], DrvInclude, ECodecs) when is_atom(Codec) ->
 
337
    ECodec = expand_codec(Codec, DrvInclude),
 
338
    expand_codecs(Codecs, DrvInclude, [ECodec|ECodecs]).
 
339
 
 
340
expand_codec(Codec, flex) ->
 
341
    case Codec of
 
342
        pretty ->
 
343
            [{Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
344
             {Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
345
             {Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
346
             {Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
347
             {Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
348
             {Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
349
             {Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
350
             {Codec, megaco_pretty_text_encoder, [flex_scanner]}];
 
351
        compact ->
 
352
            [{Codec, megaco_compact_text_encoder, [flex_scanner]},
 
353
             {Codec, megaco_compact_text_encoder, [flex_scanner]},
 
354
             {Codec, megaco_compact_text_encoder, [flex_scanner]},
 
355
             {Codec, megaco_compact_text_encoder, [flex_scanner]},
 
356
             {Codec, megaco_compact_text_encoder, [flex_scanner]},
 
357
             {Codec, megaco_compact_text_encoder, [flex_scanner]},
 
358
             {Codec, megaco_compact_text_encoder, [flex_scanner]},
 
359
             {Codec, megaco_compact_text_encoder, [flex_scanner]}];
 
360
        ber ->
 
361
            [];
 
362
        per ->
 
363
            [];
 
364
        erlang ->
 
365
            [];
 
366
        Else ->
 
367
            error({invalid_codec, Else})
 
368
    end;
 
369
expand_codec(Codec, only_drv) ->
 
370
    case Codec of
 
371
        pretty ->
 
372
            [{Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
373
             {Codec, megaco_pretty_text_encoder, [flex_scanner]}];
 
374
        compact ->
 
375
            [{Codec, megaco_compact_text_encoder, [flex_scanner]},
 
376
             {Codec, megaco_compact_text_encoder, [flex_scanner]}];
 
377
        ber ->
 
378
            [{Codec, megaco_ber_bin_encoder, [driver,native]},
 
379
             {Codec, megaco_ber_bin_encoder, [driver]},
 
380
             {Codec, megaco_ber_bin_encoder, [driver,native]},
 
381
             {Codec, megaco_ber_bin_encoder, [driver]}];
 
382
        per ->
 
383
            [{Codec, megaco_per_bin_encoder, [driver,native]},
 
384
             {Codec, megaco_per_bin_encoder, [native]},
 
385
             {Codec, megaco_per_bin_encoder, [driver,native]},
 
386
             {Codec, megaco_per_bin_encoder, [native]}];
 
387
        erlang ->
 
388
            Encoder = megaco_erl_dist_encoder,
 
389
            [
 
390
             {Codec, Encoder, [megaco_compressed,compressed]},
 
391
             {Codec, Encoder, [compressed]},
 
392
             {Codec, Encoder, [megaco_compressed,compressed]},
 
393
             {Codec, Encoder, [compressed]}
 
394
            ];
 
395
        Else ->
 
396
            error({invalid_codec, Else})
 
397
    end;
 
398
expand_codec(Codec, no_drv) ->
 
399
    case Codec of
 
400
        pretty ->
 
401
            [{Codec, megaco_pretty_text_encoder, []},
 
402
             {Codec, megaco_pretty_text_encoder, []}];
 
403
        compact ->
 
404
            [{Codec, megaco_compact_text_encoder, []},
 
405
             {Codec, megaco_compact_text_encoder, []}];
 
406
        ber ->
 
407
            [{Codec, megaco_ber_bin_encoder, [native]},
 
408
             {Codec, megaco_ber_bin_encoder, []},
 
409
             {Codec, megaco_ber_bin_encoder, [native]},
 
410
             {Codec, megaco_ber_bin_encoder, []}];
 
411
        per ->
 
412
            [{Codec, megaco_per_bin_encoder, [native]},
 
413
             {Codec, megaco_per_bin_encoder, []},
 
414
             {Codec, megaco_per_bin_encoder, [native]},
 
415
             {Codec, megaco_per_bin_encoder, []}];
 
416
        erlang ->
 
417
            Encoder = megaco_erl_dist_encoder,
 
418
            [
 
419
             {Codec, Encoder, [megaco_compressed]},
 
420
             {Codec, Encoder, []},
 
421
             {Codec, Encoder, [megaco_compressed]},
 
422
             {Codec, Encoder, []}
 
423
            ];
 
424
        Else ->
 
425
            error({invalid_codec, Else})
 
426
    end;
 
427
expand_codec(Codec, _) ->
 
428
    case Codec of
 
429
        pretty ->
 
430
            [{Codec, megaco_pretty_text_encoder, [flex_scanner]},
 
431
             {Codec, megaco_pretty_text_encoder, []}];
 
432
        compact ->
 
433
            [{Codec, megaco_compact_text_encoder, [flex_scanner]},
 
434
             {Codec, megaco_compact_text_encoder, []}];
 
435
        ber ->
 
436
            [{Codec, megaco_ber_bin_encoder, [driver,native]},
 
437
             {Codec, megaco_ber_bin_encoder, [native]},
 
438
             {Codec, megaco_ber_bin_encoder, [driver]},
 
439
             {Codec, megaco_ber_bin_encoder, []}];
 
440
        per ->
 
441
            [{Codec, megaco_per_bin_encoder, [driver,native]},
 
442
             {Codec, megaco_per_bin_encoder, [native]},
 
443
             {Codec, megaco_per_bin_encoder, [driver]},
 
444
             {Codec, megaco_per_bin_encoder, []}];
 
445
        erlang ->
 
446
            Encoder = megaco_erl_dist_encoder,
 
447
            [
 
448
             {Codec, Encoder, [megaco_compressed,compressed]},
 
449
             {Codec, Encoder, [compressed]},
 
450
             {Codec, Encoder, [megaco_compressed]},
 
451
             {Codec, Encoder, []}
 
452
            ];
 
453
        Else ->
 
454
            error({invalid_codec, Else})
417
455
    end.
418
456
 
419
457
 
451
489
 
452
490
flex_scanner_handler(Pid) ->
453
491
    case (catch megaco_flex_scanner:start()) of
454
 
        {ok, Port} when is_port(Port) ->
455
 
            Pid ! {flex_scanner_started, self(), {flex, Port}},
456
 
            flex_scanner_handler(Pid, Port);
 
492
        {ok, PortOrPorts} ->
 
493
            Pid ! {flex_scanner_started, self(), {flex, PortOrPorts}},
 
494
            flex_scanner_handler_loop(Pid, PortOrPorts);
457
495
        {error, {load_driver, {open_error, Reason}}} ->
458
496
            Error = {failed_loading_flex_scanner_driver, Reason},
459
497
            Pid ! {flex_scanner_error, Error},
464
502
            exit(Error)
465
503
    end.
466
504
 
467
 
flex_scanner_handler(Pid, Port) ->
 
505
flex_scanner_handler_loop(Pid, PortOrPorts) ->
468
506
    receive
469
507
        {ping, Pinger} ->
470
508
            Pinger ! {pong, self()},
471
 
            flex_scanner_handler(Pid, Port);
472
 
        {'EXIT', Port, Reason} ->
 
509
            flex_scanner_handler_loop(Pid, PortOrPorts);
 
510
        {'EXIT', Port, Reason} when (Port =:= PortOrPorts) ->
473
511
            Pid ! {flex_scanner_exit, Reason},
474
512
            exit({flex_scanner_exit, Reason});
 
513
        {'EXIT', Port, Reason} when is_port(Port) ->
 
514
            case megaco_flex_scanner:is_scanner_port(Port, PortOrPorts) of
 
515
                true ->
 
516
                    Pid ! {flex_scanner_exit, Reason},
 
517
                    exit({flex_scanner_exit, Reason});
 
518
                false ->
 
519
                    %% Just ignore this crap
 
520
                    flex_scanner_handler_loop(Pid, PortOrPorts)
 
521
            end;
475
522
        stop_flex_scanner ->
476
 
            megaco_flex_scanner:stop(Port),
 
523
            megaco_flex_scanner:stop(PortOrPorts),
477
524
            exit(normal);
478
525
        _Other ->
479
 
            flex_scanner_handler(Pid, Port)
 
526
            flex_scanner_handler_loop(Pid, PortOrPorts)
480
527
    end.
481
528
 
482
529