1
%% ``The contents of this file are subject to the Erlang Public License,
2
%% Version 1.1, (the "License"); you may not use this file except in
3
%% compliance with the License. You should have received a copy of the
4
%% Erlang Public License along with this software. If not, it can be
5
%% retrieved via the world wide web at http://www.erlang.org/.
7
%% Software distributed under the License is distributed on an "AS IS"
8
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
9
%% the License for the specific language governing rights and limitations
12
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
13
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
14
%% AB. All Rights Reserved.''
18
%%----------------------------------------------------------------------
19
%% Purpose: Encode V3 Megaco/H.248 text messages from internal form
20
%%----------------------------------------------------------------------
22
%% -define(d(F,A), io:format("~w:" ++ F ++ "~n", [?MODULE|A])).
24
-define(META_ENC(Type, Item), Item) .
25
%% -define(META_ENC(Type, Item), megaco_meta_package:encode(text, Type, Item)).
26
%% -define(META_DEC(Type, Item), megaco_meta_package:decode(text, Type, Item)).
28
enc_MegacoMessage(Val) ->
30
enc_MegacoMessage(Val, State).
32
enc_MegacoMessage(Val, State)
33
when record(Val, 'MegacoMessage') ->
36
enc_AuthenticationHeader(Val#'MegacoMessage'.authHeader, State),
37
enc_Message(Val#'MegacoMessage'.mess, State)
40
%% Note that encoding the transaction this way
41
%% make the message look a bit strange.
42
enc_Transaction(Val) ->
44
enc_Transaction(Val, State).
46
%% Note that encoding the action request's this way
47
%% make the message look a bit strange.
48
enc_ActionRequests(Val) ->
50
enc_TransactionRequest_actions(Val, State).
52
%% Note that encoding the action request this way
53
%% make the message look a bit strange.
54
enc_ActionRequest(Val) ->
56
enc_ActionRequest(Val, State).
58
enc_CommandRequest(Val) ->
60
enc_CommandRequest(Val, State).
62
enc_ActionReply(Val) ->
64
enc_ActionReply(Val, State).
66
enc_AuthenticationHeader(asn1_NOVALUE, _State) ->
68
enc_AuthenticationHeader(Val, State)
69
when record(Val, 'AuthenticationHeader') ->
73
enc_SecurityParmIndex(Val#'AuthenticationHeader'.secParmIndex, State),
75
enc_SequenceNum(Val#'AuthenticationHeader'.seqNum, State),
77
enc_AuthData(Val#'AuthenticationHeader'.ad, State),
81
enc_SecurityParmIndex({'SecurityParmIndex',Val}, State) ->
82
enc_SecurityParmIndex(Val, State);
83
enc_SecurityParmIndex(Val, State) ->
86
enc_HEXDIG(Val, State, 8, 8)
89
enc_SequenceNum({'SequenceNum',Val}, State) ->
90
enc_SequenceNum(Val, State);
91
enc_SequenceNum(Val, State) ->
94
enc_HEXDIG(Val, State, 8, 8)
97
enc_AuthData({'AuthData',Val}, State) ->
98
enc_AuthData(Val, State);
99
enc_AuthData(Val, State) ->
102
enc_HEXDIG(Val, State, 24, 64) %% OTP-4710
105
enc_Message(Val, State)
106
when record(Val, 'Message') ->
110
enc_version(Val#'Message'.version, State),
112
enc_MId(Val#'Message'.mId, State),
114
enc_Message_messageBody(Val#'Message'.messageBody, State)
117
enc_version(Val, State) when integer(Val), Val >= 0 ->
118
enc_DIGIT(Val, State, 0, 99).
120
enc_Message_messageBody({'Message_messageBody',Val}, State) ->
121
enc_Message_messageBody(Val, State);
122
enc_Message_messageBody({Tag, Val}, State) ->
125
enc_ErrorDescriptor(Val, State);
127
enc_Message_messageBody_transactions(Val, State);
129
error({invalid_messageBody_tag, Tag})
132
enc_Message_messageBody_transactions({'Message_messageBody_transactions',Val},
134
enc_Message_messageBody_transactions(Val, State);
135
enc_Message_messageBody_transactions(Val, State)
136
when list(Val), Val /= []->
137
[enc_Transaction(T, State) || T <- Val].
139
enc_MId({'MId',Val}, State) ->
141
enc_MId({Tag, Val}, State) ->
144
enc_IP4Address(Val, State);
146
enc_IP6Address(Val, State);
148
enc_DomainName(Val, State);
150
enc_PathName(Val, State);
152
enc_mtpAddress(Val, State);
154
error({invalid_MId_tag, Tag})
157
enc_mtpAddress(Val, State) ->
161
enc_OCTET_STRING(Val, State, 2, 4),
165
enc_DomainName(Val, State)
166
when record(Val, 'DomainName') ->
169
%% BUGBUG: (ALPHA / DIGIT) *63(ALPHA / DIGIT / "-" / ".")
170
enc_STRING(Val#'DomainName'.name, State, 1, 64),
172
case Val#'DomainName'.portNumber of
178
enc_portNumber(PortNumber, State)
183
enc_IP4Address(Val, State)
184
when record(Val, 'IP4Address') ->
185
[A1, A2, A3, A4] = Val#'IP4Address'.address,
188
enc_V4hex(A1, State),
190
enc_V4hex(A2, State),
192
enc_V4hex(A3, State),
194
enc_V4hex(A4, State),
196
case Val#'IP4Address'.portNumber of
202
enc_portNumber(PortNumber, State)
207
enc_V4hex(Val, State) ->
208
enc_DIGIT(Val, State, 0, 255).
210
enc_IP6Address(Val, State)
211
when record(Val, 'IP6Address'),
212
list(Val#'IP6Address'.address),
213
length(Val#'IP6Address'.address) == 16 ->
216
enc_IP6Address_address(Val#'IP6Address'.address, State),
218
case Val#'IP6Address'.portNumber of
224
enc_portNumber(PortNumber, State)
229
enc_IP6Address_address([0, 0|Addr], State) ->
230
enc_IP6Address_address2(Addr, 1, false, true, State);
231
enc_IP6Address_address(Addr, State) ->
232
enc_IP6Address_address2(Addr, 0, false, false, State).
234
enc_IP6Address_address2([0,0], 0, _Padding, _First, _State) ->
236
enc_IP6Address_address2([0,0], PadN, false, true, _State) when PadN > 0 ->
237
[$:, $:]; % Padding from the beginning (all zero's)
238
enc_IP6Address_address2([0,0], PadN, false, false, _State) when PadN > 0 ->
239
[$:]; % Padding in the middle or end
240
enc_IP6Address_address2([0,0], _, true, _First, _State) ->
242
enc_IP6Address_address2([N1,N2], 0, _Padding, _First, State) ->
243
[enc_hex4([N1, N2], State)];
244
enc_IP6Address_address2([N1,N2], 1, _Padding, _First, State) ->
245
[$0, $:, enc_hex4([N1, N2], State)];
246
enc_IP6Address_address2([N1,N2], PadN, false, true, State) when PadN > 1 ->
247
[$:, $:, enc_hex4([N1, N2], State)];
248
enc_IP6Address_address2([N1,N2], PadN, false, false, State) when PadN > 1 ->
249
[$:, enc_hex4([N1, N2], State)];
250
enc_IP6Address_address2([N1,N2], _PadN, true, _First, State) ->
251
[enc_hex4([N1, N2], State)];
252
enc_IP6Address_address2([0, 0|Ns], PadN, false, First, State) ->
253
enc_IP6Address_address2(Ns, PadN+1, false, First, State);
254
enc_IP6Address_address2([0, 0|Ns], _PadN, true, _First, State) ->
258
enc_IP6Address_address2(Ns, 0, true, false, State)
260
enc_IP6Address_address2([N1, N2|Ns], 0, Padded, _First, State) ->
262
enc_hex4([N1, N2], State),
264
enc_IP6Address_address2(Ns, 0, Padded, false, State)
266
enc_IP6Address_address2([N1, N2|Ns], 1, Padded, _First, State) ->
270
enc_hex4([N1, N2], State),
272
enc_IP6Address_address2(Ns, 0, Padded, false, State)
274
enc_IP6Address_address2([N1, N2|Ns], PadN, false, true, State) when PadN > 1 ->
275
%% Padding from the beginning
279
enc_hex4([N1, N2], State),
281
enc_IP6Address_address2(Ns, 0, true, false, State)
283
enc_IP6Address_address2([N1, N2|Ns], PadN, false, false, State)
286
$:, %% The other ':' has already added
287
enc_hex4([N1, N2], State),
289
enc_IP6Address_address2(Ns, 0, true, false, State)
291
enc_IP6Address_address2([N1, N2|Ns], _PadN, true, _First, State) ->
293
enc_hex4([N1, N2], State),
295
enc_IP6Address_address2(Ns, 0, true, false, State)
299
enc_hex4([0,0], _State) ->
301
enc_hex4([0,N], _State) ->
303
enc_hex4([N1, N2], _State) when N2 =< 15 ->
304
[hex(N1), $0, hex(N2)];
305
enc_hex4([N1, N2], _State) ->
308
enc_PathName({'PathName',Val}, State) ->
309
enc_PathName(Val, State);
310
enc_PathName(Val, State) ->
311
%% BUGBUG: ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" )
312
%% BUGBUG: ["@" pathDomainName ]
313
enc_STRING(Val, State, 1, 64).
315
enc_Transaction(Bin, _State) when binary(Bin) ->
316
[Bin]; %% Already encoded...
317
enc_Transaction({'Transaction',Val}, State) ->
318
enc_Transaction(Val, State);
319
enc_Transaction({Tag, Val}, State) ->
321
transactionRequest ->
322
enc_TransactionRequest(Val, State);
323
transactionPending ->
324
enc_TransactionPending(Val, State);
326
enc_TransactionReply(Val, State);
327
transactionResponseAck ->
328
enc_TransactionResponseAck(Val, State);
330
%% enc_SegmentReply(Val, State);
332
error({invalid_Transaction_tag, Tag})
335
enc_TransactionResponseAck([Mand | Opt], State) ->
338
?LBRKT_INDENT(State),
339
[enc_TransactionAck(Mand, State) |
340
[[?COMMA_INDENT(State), enc_TransactionAck(Val, State)] || Val <- Opt]],
344
enc_TransactionAck(Val, State)
345
when record(Val, 'TransactionAck') ->
347
enc_TransactionId(Val#'TransactionAck'.firstAck, ?INC_INDENT(State)),
348
case Val#'TransactionAck'.lastAck of
352
["-",enc_TransactionId(LastAck, State)]
356
enc_TransactionId({'TransactionId',Val}, State) ->
357
enc_TransactionId(Val, State);
358
enc_TransactionId(Val, State) ->
359
enc_UINT32(Val, State).
361
enc_TransactionRequest(#'TransactionRequest'{transactionId = Tid,
362
actions = Acts}, State) ->
366
enc_TransactionId(Tid, State),
367
?LBRKT_INDENT(State),
368
enc_TransactionRequest_actions(Acts, ?INC_INDENT(State)),
371
enc_TransactionRequest(Bin, _State) when binary(Bin) ->
374
enc_TransactionRequest_actions(Bin, _State) when binary(Bin) ->
375
[Bin]; %% Already encoded...
376
enc_TransactionRequest_actions({'TransactionRequest_actions',Val}, State) ->
377
enc_TransactionRequest_actions(Val, State);
378
enc_TransactionRequest_actions([Mand | Opt], State) ->
379
[enc_ActionRequest(Mand, State) |
380
[[?COMMA_INDENT(State), enc_ActionRequest(Val, State)] || Val <- Opt]].
382
enc_TransactionPending(#'TransactionPending'{transactionId = Tid}, State) ->
385
enc_TransactionId(Tid, State),
386
?LBRKT_INDENT(State),
389
enc_TransactionPending(Bin, _State) when binary(Bin) ->
392
enc_TransactionReply(#'TransactionReply'{transactionId = Tid,
393
immAckRequired = Req,
394
transactionResult = Res%% ,
395
%% segmentationNumber = SegNo,
396
%% segmentationComplete = SegCompl
402
enc_TransactionId(Tid, State),
403
?LBRKT_INDENT(State),
404
enc_immAckRequired(Req, State),
405
enc_TransactionReply_transactionResult(Res, ?INC_INDENT(State)),
408
enc_TransactionReply(Bin, _State) when binary(Bin) ->
411
enc_immAckRequired(Val, _State) ->
416
[?ImmAckRequiredToken, ?COMMA_INDENT(?INC_INDENT(_State))]
419
enc_TransactionReply_transactionResult({'TransactionReply_transactionResult',
421
enc_TransactionReply_transactionResult(Val, State);
422
enc_TransactionReply_transactionResult({Tag, Val}, State) ->
425
enc_ErrorDescriptor(Val, State);
427
enc_TransactionReply_transactionResult_actionReplies(Val, State);
429
error({invalid_TransactionReply_transactionResult_tag, Tag})
432
enc_TransactionReply_transactionResult_actionReplies({'TransactionReply_transactionResult_actionReplies',Val}, State) ->
433
enc_TransactionReply_transactionResult_actionReplies(Val, State);
434
enc_TransactionReply_transactionResult_actionReplies([Mand | Opt], State) ->
435
[enc_ActionReply(Mand, State),
436
[[?COMMA_INDENT(State), enc_ActionReply(Val, State)] || Val <- Opt]].
438
enc_ErrorDescriptor(Val, State)
439
when record(Val, 'ErrorDescriptor') ->
443
enc_ErrorCode(Val#'ErrorDescriptor'.errorCode, State),
445
case Val#'ErrorDescriptor'.errorText of
449
enc_ErrorText(ErrorText, State)
454
enc_ErrorCode({'ErrorCode',Val}, State)->
455
enc_ErrorCode(Val, State);
456
enc_ErrorCode(Val, State) ->
457
enc_DIGIT(Val, State, 0, 999).
459
enc_ErrorText({'ErrorText',Val}, State) ->
460
enc_ErrorText(Val, State);
461
enc_ErrorText(Val, State) ->
462
enc_QUOTED_STRING(Val, State).
464
enc_ContextID({'ContextID',Val}, State) ->
465
enc_ContextID(Val, State);
466
enc_ContextID(Val, State) ->
468
?megaco_all_context_id -> $*;
469
?megaco_null_context_id -> $-;
470
?megaco_choose_context_id -> $$;
471
Int when integer(Int) -> enc_UINT32(Int, State)
474
enc_ActionRequest(Bin, _State) when binary(Bin) ->
475
[Bin]; %% Already encoded...
476
enc_ActionRequest(Val, State)
477
when record(Val, 'ActionRequest') ->
481
enc_ContextID(Val#'ActionRequest'.contextId, State),
482
?LBRKT_INDENT(State),
483
enc_list([{[Val#'ActionRequest'.contextRequest],
484
fun enc_ContextRequest/2},
485
{[Val#'ActionRequest'.contextAttrAuditReq],
486
fun enc_ContextAttrAuditRequest/2},
487
{Val#'ActionRequest'.commandRequests,
488
fun enc_CommandRequest/2}],
494
enc_ActionReply(#'ActionReply'{contextId = Id,
495
errorDescriptor = asn1_NOVALUE,
496
contextReply = asn1_NOVALUE,
499
%% d("enc_ActionReply -> entry with"
500
%% "~n Id: ~p", [Id]),
504
enc_ContextID(Id, State)
506
enc_ActionReply(#'ActionReply'{contextId = Id,
507
errorDescriptor = ED,
508
contextReply = CtxRep,
509
commandReply = CmdRep},
511
%% d("enc_ActionReply -> entry with"
515
%% "~n CmdRep: ~p", [Id, ED, CtxRep, CmdRep]),
519
enc_ContextID(Id, State),
520
?LBRKT_INDENT(State),
521
do_enc_ActionReply(ED, CtxRep, CmdRep, State),
525
do_enc_ActionReply(asn1_NOVALUE, CtxRep, [], State)
526
when CtxRep =/= asn1_NOVALUE ->
528
enc_ContextRequest(CtxRep, ?INC_INDENT(State))
530
do_enc_ActionReply(asn1_NOVALUE, CtxRep, CmdRep, State)
531
when CtxRep =/= asn1_NOVALUE, CmdRep =/= [] ->
533
enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
534
?COMMA_INDENT(?INC_INDENT(State)),
535
enc_list([{CmdRep, fun enc_CommandReply/2}],
538
do_enc_ActionReply(asn1_NOVALUE, asn1_NOVALUE, CmdRep, State)
539
when CmdRep =/= [] ->
541
enc_list([{CmdRep, fun enc_CommandReply/2}],
544
do_enc_ActionReply(ED, CtxRep, [], State)
545
when ED =/= asn1_NOVALUE, CtxRep =/= asn1_NOVALUE ->
547
enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
548
?COMMA_INDENT(?INC_INDENT(State)),
549
enc_list([{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
552
do_enc_ActionReply(ED, asn1_NOVALUE, CmdRep, State)
553
when ED =/= asn1_NOVALUE, CmdRep =/= [] ->
555
enc_list([{CmdRep, fun enc_CommandReply/2},
556
{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
559
do_enc_ActionReply(ED, CtxRep, CmdRep, State)
560
when ED =/= asn1_NOVALUE, CtxRep =/= asn1_NOVALUE, CmdRep =/= [] ->
562
enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
563
?COMMA_INDENT(?INC_INDENT(State)),
564
enc_list([{CmdRep, fun enc_CommandReply/2},
565
{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
568
do_enc_ActionReply(ED, asn1_NOVALUE, [], State)
569
when ED =/= asn1_NOVALUE ->
571
enc_ErrorDescriptor(ED, ?INC_INDENT(State))
575
enc_ContextRequest_priority(asn1_NOVALUE, _State) ->
577
enc_ContextRequest_priority(Val, _State) ->
578
{[Val], fun(X,S) -> [?PriorityToken,?EQUAL,enc_UINT16(X, S)] end}.
580
enc_ContextRequest_emergency(asn1_NOVALUE, _State) ->
582
enc_ContextRequest_emergency(true, _State) ->
583
{[?EmergencyToken], fun(Elem, _) -> Elem end};
584
enc_ContextRequest_emergency(false, _State) ->
585
{[?EmergencyOffToken], fun(Elem, _) -> Elem end}.
587
enc_ContextRequest_topologyReq(asn1_NOVALUE, _State) ->
589
enc_ContextRequest_topologyReq({'ContextRequest_topologyReq',
590
asn1_NOVALUE}, _State) ->
592
enc_ContextRequest_topologyReq({'ContextRequest_topologyReq',
594
{List, fun enc_TopologyRequest/2};
595
enc_ContextRequest_topologyReq(List, _State) ->
596
{[List], fun enc_TopologyRequest/2}.
598
enc_ContextRequest_iepscallind(asn1_NOVALUE, _State) ->
600
enc_ContextRequest_iepscallind(Bool, _State) ->
601
{[Bool], fun enc_iepsValue/2}.
603
enc_ContextRequest_contextProp(asn1_NOVALUE, _State) ->
605
enc_ContextRequest_contextProp([], _State) ->
607
enc_ContextRequest_contextProp(Props, _State) ->
608
{[Props], fun(Elem, S) -> enc_contextAttrDescriptor(Elem, contextProps, S) end}.
610
enc_ContextRequest_contextList(asn1_NOVALUE, _State) ->
612
enc_ContextRequest_contextList([], _State) ->
614
enc_ContextRequest_contextList(Props, _State) ->
615
{[Props], fun(Elem, S) ->
616
enc_contextAttrDescriptor(Elem, contextList, S)
619
enc_contextAttrDescriptor([Mand|Opt], contextProps, State) ->
622
?LBRKT_INDENT(State),
623
[enc_PropertyParm(Mand, State) |
624
[[?COMMA_INDENT(State), enc_PropertyParm(Val, State)] || Val <- Opt]],
627
enc_contextAttrDescriptor(CtxIdList, contextList, State) ->
630
?LBRKT_INDENT(State),
631
enc_contextIdList(CtxIdList, ?INC_INDENT(State)),
635
enc_contextIdList([Mand|Opt], State) ->
636
State2 = ?INC_INDENT(State),
640
?LBRKT_INDENT(State),
641
[enc_ContextID(Mand, State2) |
642
[[?COMMA_INDENT(State2), enc_ContextID(Val, State2)] || Val <- Opt]],
646
enc_ContextRequest(asn1_NOVALUE, _State) ->
648
enc_ContextRequest(#'ContextRequest'{priority = asn1_NOVALUE,
649
emergency = asn1_NOVALUE,
650
topologyReq = asn1_NOVALUE,
651
iepscallind = asn1_NOVALUE,
652
contextProp = asn1_NOVALUE,
653
contextList = asn1_NOVALUE}, _State) ->
655
enc_ContextRequest(#'ContextRequest'{priority = asn1_NOVALUE,
656
emergency = asn1_NOVALUE,
658
iepscallind = asn1_NOVALUE,
660
contextList = []}, _State) ->
662
enc_ContextRequest(#'ContextRequest'{priority = Prio,
667
contextList = CL}, State) ->
669
enc_list([enc_ContextRequest_priority(Prio, State),
670
enc_ContextRequest_emergency(Em, State),
671
enc_ContextRequest_topologyReq(TR, State),
672
enc_ContextRequest_iepscallind(Ieps, State),
673
enc_ContextRequest_contextProp(CP, State),
674
enc_ContextRequest_contextList(CL, State)],
679
%% -- contextAudit --
680
%% contextAudit = ContextAuditToken LBRKT
681
%% (contextAuditProperties *(COMMA contextAuditProperties)) /
682
%% indAudcontextAttrDesscriptor
684
%% contextAuditProperties =
685
%% (TopologyToken / EmergencyToken / PriorityToken /
686
%% IEPSToken / pkgdName / contextAuditSelect)
687
%% contextAuditSelect =
688
%% priority / emergencyValue / iepsValue /
689
%% contextAttrDescriptor / auditSelectLogic
690
%% indAudcontextAttrDesscriptor =
691
%% ContextAttrToken LBRKT
692
%% (contextAuditProperties *(COMMA contextAuditProperties))
695
%% This could actually either be
696
%% a) a list of contextAuditProperties:
697
%% contextAuditProperties *(COMMA contextAuditProperties)
698
%% b) a indAudcontextAttrDescriptor
699
%% But since b) actually has the same content as a) with
700
%% the extra ContextAttrToken, there does not seem to be any
701
%% reason for using it.
702
enc_ContextAttrAuditRequest(asn1_NOVALUE, _State) ->
704
enc_ContextAttrAuditRequest(
705
#'ContextAttrAuditRequest'{topology = asn1_NOVALUE,
706
emergency = asn1_NOVALUE,
707
priority = asn1_NOVALUE,
708
iepscallind = asn1_NOVALUE,
709
contextPropAud = asn1_NOVALUE,
710
selectpriority = asn1_NOVALUE,
711
selectemergency = asn1_NOVALUE,
712
selectiepscallind = asn1_NOVALUE,
713
selectLogic = asn1_NOVALUE}, _State) ->
715
enc_ContextAttrAuditRequest(
716
#'ContextAttrAuditRequest'{topology = asn1_NOVALUE,
717
emergency = asn1_NOVALUE,
718
priority = asn1_NOVALUE,
719
iepscallind = asn1_NOVALUE,
721
selectpriority = asn1_NOVALUE,
722
selectemergency = asn1_NOVALUE,
723
selectiepscallind = asn1_NOVALUE,
724
selectLogic = asn1_NOVALUE}, _State) ->
726
enc_ContextAttrAuditRequest(
727
#'ContextAttrAuditRequest'{topology = Top,
731
contextPropAud = CPA,
732
selectpriority = SPrio,
733
selectemergency = SEm,
734
selectiepscallind = SIeps,
735
selectLogic = SL}, State) ->
738
?LBRKT_INDENT(State),
739
enc_list([{[Top], fun('NULL', _) -> ?TopologyToken end},
740
{[Em], fun('NULL', _) -> ?EmergencyToken end},
741
{[Prio], fun('NULL', _) -> ?PriorityToken end},
742
{[Ieps], fun('NULL', _) -> ?IEPSToken end},
743
{CPA, fun enc_IndAudPropertyParm/2},
744
enc_ContextAttrAuditRequest_selectpriority(SPrio, State),
745
enc_ContextAttrAuditRequest_selectemergency(SEm, State),
746
enc_ContextAttrAuditRequest_selectiepscallind(SIeps, State),
747
enc_ContextAttrAuditRequest_selectLogic(SL, State)],
752
enc_ContextAttrAuditRequest_selectpriority(asn1_NOVALUE, _State) ->
754
enc_ContextAttrAuditRequest_selectpriority(SPrio, _State) ->
755
{[SPrio], fun(X,S) -> [?PriorityToken,?EQUAL,enc_UINT16(X, S)] end}.
757
enc_ContextAttrAuditRequest_selectemergency(asn1_NOVALUE, _State) ->
759
enc_ContextAttrAuditRequest_selectemergency(SEm, _State) ->
760
{[SEm], fun(X,S) -> enc_emergencyValue(X, S) end}.
762
enc_ContextAttrAuditRequest_selectiepscallind(asn1_NOVALUE, _State) ->
764
enc_ContextAttrAuditRequest_selectiepscallind(SEm, _State) ->
765
{[SEm], fun(X,S) -> enc_iepsValue(X, S) end}.
767
enc_ContextAttrAuditRequest_selectLogic(asn1_NOVALUE, _State) ->
769
enc_ContextAttrAuditRequest_selectLogic({andAUDITSelect, 'NULL'}, _State) ->
770
{[], dummy}; % This is default so, there is no reason to add it
771
enc_ContextAttrAuditRequest_selectLogic({orAUDITSelect, 'NULL'}, _State) ->
772
{[?OrAUDITselectToken], fun(Elem, _) -> Elem end}.
774
enc_emergencyValue(true, _) ->
775
[?EmergencyValueToken,?EQUAL,?EmergencyToken];
776
enc_emergencyValue(_, _) ->
777
[?EmergencyValueToken,?EQUAL,?EmergencyOffToken].
780
%% enc_IndAudContextAttrDescriptor(
781
%% #'ContextAttrAuditRequest'{topology = Top,
784
%% iepscallind = Ieps,
785
%% contextPropAud = CPA,
786
%% selectpriority = SelPrio,
787
%% selectemergency = SelEm,
788
%% selectiepscallind = SelIeps,
789
%% selectLogic = SelLog}, State) ->
791
%% ?ContextAttrToken,
792
%% ?LBRKT_INDENT(State),
793
%% enc_list([{[Top], fun('NULL', _) -> ?TopologyToken end},
794
%% {[Em], fun('NULL', _) -> ?EmergencyToken end},
795
%% {[Prio], fun('NULL', _) -> ?PriorityToken end},
796
%% {[Ieps], fun('NULL', _) -> ?IEPSToken end},
797
%% {CPA, fun enc_IndAudPropertyParm/2}],
798
%% ?INC_INDENT(State)),
799
%% ?RBRKT_INDENT(State)
802
enc_CommandRequest(Val, State)
803
when record(Val, 'CommandRequest') ->
804
%% d("enc_CommandRequest -> entry with"
805
%% "~n Val: ~p", [Val]),
807
case Val#'CommandRequest'.optional of
813
case Val#'CommandRequest'.wildcardReturn of
819
enc_Command(Val#'CommandRequest'.command, State)
822
enc_Command({'Command',Val}, State) ->
823
enc_Command(Val, State);
824
enc_Command({Tag, Val}, State) ->
825
%% d("enc_Command -> entry with"
827
%% "~n Val: ~p", [Tag, Val]),
830
[?AddToken, enc_AmmRequest(Val, State)];
832
[?MoveToken, enc_AmmRequest(Val, State)];
834
[?ModifyToken, enc_AmmRequest(Val, State)];
836
[?SubtractToken, enc_SubtractRequest(Val, State)];
838
[?AuditCapToken, enc_AuditRequest(Val, State)];
840
[?AuditValueToken, enc_AuditRequest(Val, State)];
842
[?NotifyToken, enc_NotifyRequest(Val, State)];
844
[?ServiceChangeToken, enc_ServiceChangeRequest(Val, State)];
846
error({invalid_Command_tag, Tag})
849
enc_CommandReply({'CommandReply',Val}, State) ->
850
enc_CommandReply(Val, State);
851
enc_CommandReply({Tag, Val}, State) ->
852
%% d("enc_CommandReply -> entry with"
854
%% "~n Val: ~p", [Tag, Val]),
857
[?AddToken, enc_AmmsReply(Val, State)];
859
[?MoveToken, enc_AmmsReply(Val, State)];
861
[?ModifyToken, enc_AmmsReply(Val, State)];
863
[?SubtractToken, enc_AmmsReply(Val, State)];
865
[?AuditCapToken, enc_AuditReply(Val, State)];
867
[?AuditValueToken, enc_AuditReply(Val, State)];
869
[?NotifyToken, enc_NotifyReply(Val, State)];
870
serviceChangeReply ->
871
[?ServiceChangeToken, enc_ServiceChangeReply(Val, State)];
873
error({invalid_CommandReply_tag, Tag})
876
enc_TopologyRequest(Val, State)
880
?LBRKT_INDENT(State),
881
enc_list([{Val, fun enc_TopologyRequest1/2}], ?INC_INDENT(State)),
885
enc_TopologyRequest1(
886
#'TopologyRequest'{terminationFrom = From,
888
topologyDirection = TD,
889
streamID = asn1_NOVALUE, % OPTIONAL
890
topologyDirectionExtension = asn1_NOVALUE % OPTIONAL
893
enc_TerminationID(From, State),
894
?COMMA_INDENT(State),
895
enc_TerminationID(To, State),
896
?COMMA_INDENT(State),
897
enc_TopologyDirection(TD, State)
899
enc_TopologyRequest1(
900
#'TopologyRequest'{terminationFrom = From,
902
topologyDirection = TD,
903
streamID = SID, % OPTIONAL
904
topologyDirectionExtension = asn1_NOVALUE}, % OPTIONAL
905
State) when (SID =/= asn1_NOVALUE) ->
907
enc_TerminationID(From, State),
908
?COMMA_INDENT(State),
909
enc_TerminationID(To, State),
910
?COMMA_INDENT(State),
911
enc_TopologyDirection(TD, State),
912
?COMMA_INDENT(State),
913
enc_StreamID(SID, State)
915
enc_TopologyRequest1(
916
#'TopologyRequest'{terminationFrom = From,
918
topologyDirection = TD,
919
streamID = asn1_NOVALUE, % OPTIONAL
920
topologyDirectionExtension = TDE}, % OPTIONAL
921
State) when (TDE =/= asn1_NOVALUE) ->
923
enc_TerminationID(From, State),
924
?COMMA_INDENT(State),
925
enc_TerminationID(To, State),
926
?COMMA_INDENT(State),
927
enc_TopologyDirection(TD, State),
928
?COMMA_INDENT(State),
929
enc_TopologyDirectionExtension(TDE, State)
931
enc_TopologyRequest1(
932
#'TopologyRequest'{terminationFrom = From,
934
topologyDirection = TD,
935
streamID = SID, % OPTIONAL
936
topologyDirectionExtension = TDE}, % OPTIONAL
937
State) when (SID =/= asn1_NOVALUE) and (TDE =/= asn1_NOVALUE) ->
939
enc_TerminationID(From, State),
940
?COMMA_INDENT(State),
941
enc_TerminationID(To, State),
942
?COMMA_INDENT(State),
943
enc_TopologyDirection(TD, State),
944
?COMMA_INDENT(State),
945
enc_StreamID(SID, State),
946
?COMMA_INDENT(State),
947
enc_TopologyDirectionExtension(TDE, State)
950
enc_TopologyDirection(bothway, _State) ->
952
enc_TopologyDirection(isolate, _State) ->
954
enc_TopologyDirection(oneway, _State) ->
957
enc_TopologyDirectionExtension(onewayexternal, _State) ->
958
?OnewayExternalToken;
959
enc_TopologyDirectionExtension(onewayboth, _State) ->
962
enc_iepsValue(Val, _State) ->
974
enc_AmmRequest(#'AmmRequest'{terminationID = TIDs,
975
descriptors = Ds}, State) ->
977
%% Assume that Token is added elsewhere
979
enc_termIDList(TIDs, State),
981
enc_list([{Ds, fun enc_ammDescriptor/2}], ?INC_INDENT(State)),
985
enc_ammDescriptor({Tag, Desc}, State) ->
987
mediaDescriptor -> enc_MediaDescriptor(Desc, State);
988
modemDescriptor -> enc_ModemDescriptor(Desc, State);
989
muxDescriptor -> enc_MuxDescriptor(Desc, State);
990
eventsDescriptor -> enc_EventsDescriptor(Desc, State);
991
eventBufferDescriptor -> enc_EventBufferDescriptor(Desc, State);
992
signalsDescriptor -> enc_SignalsDescriptor(Desc, State);
993
digitMapDescriptor -> enc_DigitMapDescriptor(Desc, State);
994
auditDescriptor -> enc_AuditDescriptor(Desc, State);
995
statisticsDescriptor -> enc_StatisticsDescriptor(Desc, State);
997
error({invalid_ammDescriptor_tag, Tag})
1000
enc_AmmsReply(#'AmmsReply'{terminationID = TIDs,
1001
terminationAudit = asn1_NOVALUE}, State) ->
1004
enc_termIDList(TIDs, State)
1006
enc_AmmsReply(#'AmmsReply'{terminationID = TIDs,
1007
terminationAudit = []}, State) ->
1010
enc_termIDList(TIDs, State)
1012
enc_AmmsReply(#'AmmsReply'{terminationID = TIDs,
1013
terminationAudit = Res}, State) ->
1016
enc_termIDList(TIDs, State),
1017
case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
1022
?LBRKT_INDENT(State),
1024
?RBRKT_INDENT(State)
1029
enc_SubtractRequest(#'SubtractRequest'{terminationID = TIDs,
1030
auditDescriptor = asn1_NOVALUE},
1033
%% Assume that Token is added elsewhere
1035
enc_termIDList(TIDs, State)
1037
enc_SubtractRequest(#'SubtractRequest'{terminationID = TIDs,
1038
auditDescriptor = AD},
1041
%% Assume that Token is added elsewhere
1043
enc_termIDList(TIDs, State),
1044
?LBRKT_INDENT(State),
1045
enc_AuditDescriptor(AD, ?INC_INDENT(State)),
1046
?RBRKT_INDENT(State)
1049
enc_AuditRequest(#'AuditRequest'{terminationID = TID,
1050
auditDescriptor = asn1_NOVALUE,
1051
terminationIDList = asn1_NOVALUE}, State) ->
1053
%% Assume that Token is added elsewhere
1055
enc_termIDList([TID], State)
1057
enc_AuditRequest(#'AuditRequest'{terminationID = TID,
1058
auditDescriptor = asn1_NOVALUE,
1059
terminationIDList = [TID|_] = TIDList},
1062
%% Assume that Token is added elsewhere
1064
enc_termIDList(TIDList, State)
1066
enc_AuditRequest(#'AuditRequest'{terminationID = TID,
1067
auditDescriptor = asn1_NOVALUE,
1068
terminationIDList = TIDList},
1070
error({invalid_terminationID, TID, TIDList});
1071
enc_AuditRequest(#'AuditRequest'{terminationID = TID,
1072
auditDescriptor = AD,
1073
terminationIDList = asn1_NOVALUE}, State) ->
1075
%% Assume that Token is added elsewhere
1077
enc_termIDList([TID], State),
1078
?LBRKT_INDENT(State),
1079
enc_AuditDescriptor(AD, ?INC_INDENT(State)),
1080
?RBRKT_INDENT(State)
1082
enc_AuditRequest(#'AuditRequest'{terminationID = TID,
1083
auditDescriptor = AD,
1084
terminationIDList = [TID|_] = TIDList},
1087
%% Assume that Token is added elsewhere
1089
enc_termIDList(TIDList, State),
1090
?LBRKT_INDENT(State),
1091
enc_AuditDescriptor(AD, ?INC_INDENT(State)),
1092
?RBRKT_INDENT(State)
1094
enc_AuditRequest(#'AuditRequest'{terminationID = TID,
1095
auditDescriptor = _AD,
1096
terminationIDList = TIDList},
1098
error({invalid_terminationID, TID, TIDList}).
1100
%% auditReply = (AuditValueToken / AuditCapToken )
1101
%% ( contextTerminationAudit / auditOther)
1102
%% auditOther = EQUAL TerminationID LBRKT
1103
%% terminationAudit RBRKT
1104
%% terminationAudit = auditReturnParameter *(COMMA auditReturnParameter)
1106
%% contextTerminationAudit = EQUAL CtxToken ( terminationIDList /
1107
%% LBRKT errorDescriptor RBRKT )
1108
enc_AuditReply({Tag, Val}, State) ->
1109
%% d("enc_AuditReply -> entry with"
1111
%% "~n Val: ~p", [Tag, Val]),
1113
contextAuditResult ->
1117
enc_TerminationIDList(Val, State)
1123
?LBRKT_INDENT(State),
1124
enc_ErrorDescriptor(Val, ?INC_INDENT(State)),
1125
?RBRKT_INDENT(State)
1127
auditResult when record(Val, 'AuditResult') ->
1128
enc_auditOther(Val, State);
1130
error({invalid_auditResult, Val});
1131
auditResultTermList ->
1132
enc_TermListAuditResult(Val, State);
1134
error({invalid_AuditReply_tag, Tag})
1137
%% This is actually the same as AuditResult with the exception
1138
%% that instead of terminationID we have terminationIDList.
1139
enc_TermListAuditResult(
1140
#'TermListAuditResult'{terminationIDList = TIDList,
1141
terminationAuditResult = asn1_NOVALUE}, State) ->
1142
%% d("enc_TermListAuditResult -> entry with"
1143
%% "~n TIDList: ~p", [TIDList]),
1146
enc_termIDList(TIDList, State)
1148
enc_TermListAuditResult(
1149
#'TermListAuditResult'{terminationIDList = TIDList,
1150
terminationAuditResult = []}, State) ->
1151
%% d("enc_TermListAuditResult -> entry with"
1152
%% "~n TIDList: ~p", [TIDList]),
1155
enc_termIDList(TIDList, State)
1157
enc_TermListAuditResult(
1158
#'TermListAuditResult'{terminationIDList = TIDList,
1159
terminationAuditResult = TAR}, State) ->
1160
%% d("enc_TermListAuditResult -> entry with"
1162
%% "~n TAR: ~p", [TIDList, TAR]),
1165
enc_termIDList(TIDList, State),
1166
case lists:flatten(enc_TerminationAudit(TAR, ?INC_INDENT(State))) of
1171
?LBRKT_INDENT(State),
1173
?RBRKT_INDENT(State)
1178
enc_auditOther(#'AuditResult'{terminationID = TID,
1179
terminationAuditResult = asn1_NOVALUE}, State) ->
1182
enc_termIDList([TID], State)
1184
enc_auditOther(#'AuditResult'{terminationID = TID,
1185
terminationAuditResult = []}, State) ->
1188
enc_termIDList([TID], State)
1190
enc_auditOther(#'AuditResult'{terminationID = TID,
1191
terminationAuditResult = Res}, State) ->
1194
enc_termIDList([TID], State),
1195
case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
1200
?LBRKT_INDENT(State),
1202
?RBRKT_INDENT(State)
1208
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = asn1_NOVALUE,
1209
auditPropertyToken = asn1_NOVALUE},
1211
% d("enc_AuditDescriptor(asn1_NOVALUE) -> entry"),
1216
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = [],
1217
auditPropertyToken = asn1_NOVALUE},
1219
% d("enc_AuditDescriptor([]) -> entry"),
1224
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
1225
auditPropertyToken = asn1_NOVALUE},
1230
?LBRKT_INDENT(State),
1231
enc_list([{List, fun enc_auditItem/2}], ?INC_INDENT(State)),
1232
?RBRKT_INDENT(State)
1236
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = asn1_NOVALUE,
1237
auditPropertyToken = Prop},
1242
?LBRKT_INDENT(State),
1243
enc_auditPropertyToken(Prop, ?INC_INDENT(State)),
1244
?RBRKT_INDENT(State)
1247
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
1248
auditPropertyToken = Prop},
1253
?LBRKT_INDENT(State),
1254
enc_list([{List, fun enc_auditItem/2}], ?INC_INDENT(State)),
1255
?COMMA_INDENT(State),
1256
enc_auditPropertyToken(Prop, ?INC_INDENT(State)), % v2
1257
?RBRKT_INDENT(State)
1261
enc_auditItem(signalsToken, _State) ->
1263
enc_auditItem(eventBufferToken, _State) ->
1265
enc_auditItem(eventsToken, _State) ->
1267
enc_auditItem(Val, State) ->
1268
enc_auditReturnItem(Val, State).
1271
enc_auditReturnItem(muxToken, _State) ->
1273
enc_auditReturnItem(modemToken, _State) ->
1275
enc_auditReturnItem(mediaToken, _State) ->
1277
enc_auditReturnItem(digitMapToken, _State) ->
1279
enc_auditReturnItem(statsToken, _State) ->
1281
enc_auditReturnItem(observedEventsToken, _State) ->
1282
?ObservedEventsToken;
1283
enc_auditReturnItem(packagesToken, _State) ->
1289
enc_auditPropertyToken([], _State) ->
1291
enc_auditPropertyToken([Param | Params], State) ->
1292
[enc_IndAudauditReturnParameter(Param, State),
1293
[[?COMMA_INDENT(State),
1294
enc_IndAudauditReturnParameter(P, State)] || P <- Params]].
1297
enc_IndAudauditReturnParameter({Tag, Val}, State) ->
1299
indAudMediaDescriptor ->
1300
enc_IndAudMediaDescriptor(Val, State);
1301
indAudEventsDescriptor ->
1302
enc_IndAudEventsDescriptor(Val, State);
1303
indAudSignalsDescriptor ->
1304
enc_IndAudSignalsDescriptor(Val, State);
1305
indAudDigitMapDescriptor ->
1306
enc_IndAudDigitMapDescriptor(Val, State);
1307
indAudEventBufferDescriptor ->
1308
enc_IndAudEventBufferDescriptor(Val, State);
1309
indAudStatisticsDescriptor ->
1310
enc_IndAudStatisticsDescriptor(Val, State);
1311
indAudPackagesDescriptor ->
1312
enc_IndAudPackagesDescriptor(Val, State);
1314
error({invalid_IndAudauditReturnParameter_tag, Tag})
1317
enc_IndAudMediaDescriptor(
1318
#'IndAudMediaDescriptor'{termStateDescr = asn1_NOVALUE,
1319
streams = Streams}, State) ->
1322
?LBRKT_INDENT(State),
1323
enc_IndAudMediaDescriptor_streams(Streams, ?INC_INDENT(State)),
1324
?RBRKT_INDENT(State)
1326
enc_IndAudMediaDescriptor(
1327
#'IndAudMediaDescriptor'{termStateDescr = TSD,
1328
streams = asn1_NOVALUE}, State) ->
1331
?LBRKT_INDENT(State),
1332
enc_IndAudTerminationStateDescriptor(TSD, ?INC_INDENT(State)),
1333
?RBRKT_INDENT(State)
1335
enc_IndAudMediaDescriptor(
1336
#'IndAudMediaDescriptor'{termStateDescr = TSD,
1337
streams = Streams}, State) ->
1340
?LBRKT_INDENT(State),
1341
enc_IndAudTerminationStateDescriptor(TSD, ?INC_INDENT(State)),
1342
?COMMA_INDENT(State),
1343
enc_IndAudMediaDescriptor_streams(Streams, ?INC_INDENT(State)),
1344
?RBRKT_INDENT(State)
1347
enc_IndAudMediaDescriptor_streams({oneStream, Val}, State) ->
1348
enc_IndAudStreamParms(Val, State);
1349
enc_IndAudMediaDescriptor_streams({multiStream, Val}, State) ->
1350
enc_IndAudMediaDescriptor_multiStream(Val, State);
1351
enc_IndAudMediaDescriptor_streams({Tag, _Val}, _State) ->
1352
error({invalid_IndAudMediaDescriptor_streams_tag, Tag}).
1354
enc_IndAudTerminationStateDescriptor(
1355
#'IndAudTerminationStateDescriptor'{propertyParms = [],
1356
eventBufferControl = asn1_NOVALUE,
1357
serviceState = 'NULL',
1358
serviceStateSel = asn1_NOVALUE},
1361
?TerminationStateToken,
1362
?LBRKT_INDENT(_State),
1363
?ServiceStatesToken,
1364
?RBRKT_INDENT(_State)
1366
enc_IndAudTerminationStateDescriptor(
1367
#'IndAudTerminationStateDescriptor'{propertyParms = [],
1368
eventBufferControl = asn1_NOVALUE,
1369
serviceState = asn1_NOVALUE,
1370
serviceStateSel = SSS},
1371
State) when SSS =/= asn1_NOVALUE ->
1373
?TerminationStateToken,
1374
?LBRKT_INDENT(State),
1375
enc_serviceState(SSS, State),
1376
?RBRKT_INDENT(State)
1378
enc_IndAudTerminationStateDescriptor(
1379
#'IndAudTerminationStateDescriptor'{propertyParms = [],
1380
eventBufferControl = 'NULL',
1381
serviceState = asn1_NOVALUE,
1382
serviceStateSel = asn1_NOVALUE},
1385
?TerminationStateToken,
1386
?LBRKT_INDENT(_State),
1388
?RBRKT_INDENT(_State)
1390
enc_IndAudTerminationStateDescriptor(
1391
#'IndAudTerminationStateDescriptor'{propertyParms = [Parms],
1392
eventBufferControl = asn1_NOVALUE,
1393
serviceState = asn1_NOVALUE,
1394
serviceStateSel = asn1_NOVALUE},
1396
#'IndAudPropertyParm'{name = Name} = Parms,
1398
?TerminationStateToken,
1399
?LBRKT_INDENT(State),
1400
enc_PkgdName(Name, State),
1401
?RBRKT_INDENT(State)
1404
enc_IndAudStreamParms(
1405
#'IndAudStreamParms'{localControlDescriptor = LCD,
1406
localDescriptor = LD,
1407
remoteDescriptor = RD,
1408
statisticsDescriptor = SD}, State) ->
1410
enc_list([{[LCD], fun enc_IndAudLocalControlDescriptor/2},
1411
{[LD], fun enc_remoteDescriptor/2},
1412
{[RD], fun enc_localDescriptor/2},
1413
{[SD], fun enc_IndAudStatisticsDescriptor/2}],
1417
enc_IndAudLocalControlDescriptor(
1418
#'IndAudLocalControlDescriptor'{streamMode = SM,
1422
streamModeSel = asn1_NOVALUE}, State) ->
1425
?LBRKT_INDENT(State),
1426
enc_list([{[SM], fun('NULL', _) -> ?ModeToken end},
1427
{[RV], fun('NULL', _) -> ?ReservedValueToken end},
1428
{[RG], fun('NULL', _) -> ?ReservedGroupToken end},
1429
{PP, fun enc_IndAudPropertyParm/2}],
1430
?INC_INDENT(State)),
1431
?RBRKT_INDENT(State)
1433
enc_IndAudLocalControlDescriptor(
1434
#'IndAudLocalControlDescriptor'{streamMode = asn1_NOVALUE,
1438
streamModeSel = SMS}, State) ->
1441
?LBRKT_INDENT(State),
1442
enc_list([{[RV], fun('NULL', _) -> ?ReservedValueToken end},
1443
{[RG], fun('NULL', _) -> ?ReservedGroupToken end},
1444
{ PP, fun enc_IndAudPropertyParm/2},
1445
{[SMS], fun enc_StreamMode/2}],
1446
?INC_INDENT(State)),
1447
?RBRKT_INDENT(State)
1450
enc_IndAudPropertyParm(#'IndAudPropertyParm'{name = Name, propertyParms = PP},
1453
enc_list([{[Name], fun enc_PkgdName/2},
1454
{[PP], fun enc_PropertyParm/2}], State)
1457
enc_IndAudMediaDescriptor_multiStream(Val, State) when is_list(Val) ->
1459
enc_list([{Val, fun enc_IndAudStreamDescriptor/2}], State)
1461
enc_IndAudMediaDescriptor_multiStream(Val, _State) ->
1462
error({invalid_IndAudMediaDescriptor_multiStream, Val}).
1464
enc_IndAudStreamDescriptor(#'IndAudStreamDescriptor'{streamID = SID,
1465
streamParms = Parms},
1470
enc_StreamID(SID, State),
1471
?LBRKT_INDENT(State),
1472
enc_IndAudStreamParms(Parms, ?INC_INDENT(State)),
1473
?RBRKT_INDENT(State)
1476
enc_IndAudEventBufferDescriptor(
1477
#'IndAudEventBufferDescriptor'{eventName = EvName,
1478
streamID = ID}, State) ->
1481
?LBRKT_INDENT(State),
1482
enc_PkgdName(EvName, State),
1483
enc_IndAudEventBufferDescriptor_eventSpec(ID, ?INC_INDENT(State)),
1484
?RBRKT_INDENT(State)
1487
enc_IndAudEventBufferDescriptor_eventSpec(asn1_NOVALUE, _State) ->
1490
enc_IndAudEventBufferDescriptor_eventSpec({eventParameterName, ParamName},
1493
?LBRKT_INDENT(State),
1494
enc_Name(ParamName, State),
1495
?RBRKT_INDENT(State)
1497
enc_IndAudEventBufferDescriptor_eventSpec({eventStream, ID}, State) ->
1499
?LBRKT_INDENT(State),
1500
enc_eventStream(ID, ?INC_INDENT(State)),
1501
?RBRKT_INDENT(State)
1503
enc_IndAudEventBufferDescriptor_eventSpec(ID, State) ->
1505
?LBRKT_INDENT(State),
1506
enc_eventStream(ID, ?INC_INDENT(State)),
1507
?RBRKT_INDENT(State)
1510
enc_IndAudEventsDescriptor(
1511
#'IndAudEventsDescriptor'{requestID = asn1_NOVALUE,
1513
streamID = asn1_NOVALUE}, State) ->
1516
?LBRKT_INDENT(State),
1517
enc_PkgdName(Name, State),
1518
?RBRKT_INDENT(State)
1520
enc_IndAudEventsDescriptor(
1521
#'IndAudEventsDescriptor'{requestID = RID,
1523
streamID = asn1_NOVALUE}, State) ->
1527
enc_RequestID(RID, State),
1528
?LBRKT_INDENT(State),
1529
enc_PkgdName(Name, State),
1530
?RBRKT_INDENT(State)
1534
enc_IndAudSignalsDescriptor(asn1_NOVALUE, _State) ->
1537
?LBRKT_INDENT(_State),
1538
?RBRKT_INDENT(_State)
1540
enc_IndAudSignalsDescriptor(Val, State) ->
1543
?LBRKT_INDENT(State),
1544
enc_IndAudSignalsDescriptor_value(Val, ?INC_INDENT(State)),
1545
?RBRKT_INDENT(State)
1548
enc_IndAudSignalsDescriptor_value({signal, Val}, State) ->
1549
enc_IndAudSignal(Val, State);
1550
enc_IndAudSignalsDescriptor_value({seqSigList, Val}, State) ->
1551
enc_IndAudSeqSigList(Val, State).
1553
enc_IndAudSignal(#'IndAudSignal'{signalName = SignalName,
1554
streamID = asn1_NOVALUE,
1555
signalRequestID = asn1_NOVALUE}, State) ->
1557
enc_SignalName(SignalName, State)
1559
enc_IndAudSignal(#'IndAudSignal'{signalName = SignalName,
1561
signalRequestID = SRID}, State) ->
1563
enc_SignalName(SignalName, State),
1564
?LBRKT_INDENT(State),
1565
enc_list([{[SID], fun enc_StreamID/2},
1566
{[SRID], fun enc_sigRequestID/2}],
1568
?RBRKT_INDENT(State)
1571
enc_IndAudSeqSigList(#'IndAudSeqSigList'{id = ID,
1572
signalList = asn1_NOVALUE},
1577
enc_UINT16(ID, State)
1579
enc_IndAudSeqSigList(#'IndAudSeqSigList'{id = ID,
1585
enc_UINT16(ID, State),
1586
?LBRKT_INDENT(State),
1587
enc_IndAudSignal(SL, ?INC_INDENT(State)),
1588
?RBRKT_INDENT(State)
1591
enc_IndAudDigitMapDescriptor(#'IndAudDigitMapDescriptor'{digitMapName = Name},
1596
enc_DigitMapName(Name, State)
1599
enc_IndAudStatisticsDescriptor(#'IndAudStatisticsDescriptor'{statName = Name},
1603
?LBRKT_INDENT(State),
1604
enc_PkgdName(Name, State),
1605
?RBRKT_INDENT(State)
1609
enc_IndAudPackagesDescriptor(#'IndAudPackagesDescriptor'{packageName = N,
1610
packageVersion = V},
1614
?LBRKT_INDENT(State),
1617
enc_UINT16(V, State),
1618
?RBRKT_INDENT(State)
1625
enc_TerminationAudit({'TerminationAudit', Val}, State) ->
1626
enc_TerminationAudit(Val, State);
1627
enc_TerminationAudit([Mand | Opt], State) ->
1628
[enc_AuditReturnParameter(Mand, State),
1629
[[?COMMA_INDENT(State), enc_AuditReturnParameter(Val, State)] || Val <- Opt]].
1631
enc_AuditReturnParameter({'AuditReturnParameter',Val}, State) ->
1632
enc_AuditReturnParameter(Val, State);
1633
enc_AuditReturnParameter({Tag, Val}, State) ->
1634
%% d("enc_AuditReturnParameter -> entry with"
1636
%% "~n Val: ~p", [Tag, Val]),
1639
enc_MediaDescriptor(Val, State);
1641
enc_ModemDescriptor(Val, State);
1643
enc_MuxDescriptor(Val, State);
1645
enc_EventsDescriptor(Val, State);
1646
signalsDescriptor ->
1647
enc_SignalsDescriptor(Val, State);
1648
digitMapDescriptor ->
1649
enc_DigitMapDescriptor(Val, State);
1650
observedEventsDescriptor ->
1651
enc_ObservedEventsDescriptor(Val, State);
1652
eventBufferDescriptor ->
1653
enc_EventBufferDescriptor(Val, State);
1654
statisticsDescriptor ->
1655
enc_StatisticsDescriptor(Val, State);
1656
packagesDescriptor ->
1657
enc_PackagesDescriptor(Val, State);
1659
enc_ErrorDescriptor(Val, State);
1661
enc_EmptyDescriptors(Val, State);
1663
error({invalid_AuditReturnParameter_tag, Tag})
1666
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = asn1_NOVALUE}, _State) ->
1668
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = []}, _State) ->
1670
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = List}, State) ->
1671
%% d("enc_AuditReturnParameter -> entry with"
1672
%% "~n List: ~p", [List]),
1673
enc_list([{List, fun enc_auditReturnItem/2}], State).
1676
enc_NotifyRequest(#'NotifyRequest'{terminationID = TIDs,
1677
observedEventsDescriptor = OED,
1678
errorDescriptor = asn1_NOVALUE},
1681
%% Assume that Token is added elsewhere
1683
enc_termIDList(TIDs, State),
1684
?LBRKT_INDENT(State),
1685
enc_ObservedEventsDescriptor(OED, ?INC_INDENT(State)),
1686
?RBRKT_INDENT(State)
1688
enc_NotifyRequest(#'NotifyRequest'{terminationID = TIDs,
1689
observedEventsDescriptor = OED,
1690
errorDescriptor = ED}, State) ->
1692
%% Assume that Token is added elsewhere
1694
enc_termIDList(TIDs, State),
1695
?LBRKT_INDENT(State),
1696
enc_ObservedEventsDescriptor(OED, ?INC_INDENT(State)),
1698
enc_ErrorDescriptor(ED, ?INC_INDENT(State)),
1699
?RBRKT_INDENT(State)
1702
enc_NotifyReply(#'NotifyReply'{terminationID = TIDs,
1703
errorDescriptor = asn1_NOVALUE}, State) ->
1705
%% Assume that Token is added elsewhere
1707
enc_termIDList(TIDs, State)
1709
enc_NotifyReply(#'NotifyReply'{terminationID = TIDs,
1710
errorDescriptor = ED}, State) ->
1712
%% Assume that Token is added elsewhere
1714
enc_termIDList(TIDs, State),
1715
?LBRKT_INDENT(State),
1716
enc_ErrorDescriptor(ED, ?INC_INDENT(State)),
1717
?RBRKT_INDENT(State)
1720
enc_ObservedEventsDescriptor(
1721
#'ObservedEventsDescriptor'{requestId = RID,
1722
observedEventLst = OEL}, State) ->
1724
?ObservedEventsToken,
1726
enc_RequestID(RID, State),
1727
?LBRKT_INDENT(State),
1728
enc_observedEvents(OEL, ?INC_INDENT(State)),
1729
?RBRKT_INDENT(State)
1732
enc_observedEvents([Mand | Opt], State) ->
1733
[enc_ObservedEvent(Mand, State),
1734
[[?COMMA_INDENT(State), enc_ObservedEvent(Val, State)] || Val <- Opt]].
1736
%% ;time per event, because it might be buffered
1737
%% observedEvent = [ TimeStamp LWSP COLON] LWSP
1738
%% pkgdName [ LBRKT observedEventParameter
1739
%% *(COMMA observedEventParameter) RBRKT ]
1741
%% ;at-most-once eventStream, every eventParameterName at most once
1742
%% observedEventParameter = eventStream / eventOther
1743
enc_ObservedEvent(#'ObservedEvent'{eventName = EN,
1746
timeNotation = asn1_NOVALUE}, State) ->
1749
enc_EventName(EN, State),
1751
enc_list([{[SID], fun enc_eventStream/2},
1752
{ EPL, fun enc_eventOther/2}],
1753
?INC_INDENT(State)),
1756
enc_ObservedEvent(#'ObservedEvent'{eventName = EN,
1759
timeNotation = TN}, State) ->
1761
enc_TimeNotation(TN, State),
1765
enc_EventName(EN, State),
1767
enc_list([{[SID], fun enc_eventStream/2},
1768
{EPL, fun enc_eventOther/2}],
1769
?INC_INDENT(State)),
1773
enc_EventName({'EventName', Val}, State) ->
1774
enc_EventName(Val, State);
1775
enc_EventName(Val, State) ->
1776
PkgdName = ?META_ENC(event, Val),
1777
enc_PkgdName(PkgdName, State).
1779
enc_eventStream(Val, State) ->
1783
enc_StreamID(Val, State)
1786
enc_eventOther(#'EventParameter'{eventParameterName = Name,
1788
extraInfo = Extra}, State) ->
1790
enc_Name(Name, State),
1791
enc_propertyParmValues(Value, Extra, State)
1794
enc_ServiceChangeRequest(
1795
#'ServiceChangeRequest'{terminationID = TIDs,
1796
serviceChangeParms = Parms}, State) ->
1798
%% Assume that Token is added elsewhere
1800
enc_termIDList(TIDs, State),
1801
?LBRKT_INDENT(State),
1802
enc_ServiceChangeParm(Parms, ?INC_INDENT(State)),
1803
?RBRKT_INDENT(State)
1806
%% serviceChangeReply = ServiceChangeToken EQUAL TerminationID
1807
%% [LBRKT (errorDescriptor /
1808
%% serviceChangeReplyDescriptor) RBRKT]
1809
%% serviceChangeReplyDescriptor = ServicesToken LBRKT
1810
%% servChgReplyParm *(COMMA servChgReplyParm) RBRKT
1812
%% ;at-most-once. Version is REQUIRED on first ServiceChange response
1813
%% servChgReplyParm = (serviceChangeAddress / serviceChangeMgcId /
1814
%% serviceChangeProfile / serviceChangeVersion )
1815
enc_ServiceChangeReply(
1816
#'ServiceChangeReply'{terminationID = TIDs,
1817
serviceChangeResult = Res}, State) ->
1819
%% Assume that Token is added elsewhere
1821
enc_termIDList(TIDs, State),
1822
enc_ServiceChangeResult(Res, State)
1825
enc_ServiceChangeResult({'ServiceChangeResult', Val}, State) ->
1826
enc_ServiceChangeResult(Val, State);
1827
enc_ServiceChangeResult({errorDescriptor, Val}, State) ->
1829
?LBRKT_INDENT(State),
1830
enc_ErrorDescriptor(Val, ?INC_INDENT(State)),
1831
?RBRKT_INDENT(State)
1833
enc_ServiceChangeResult({serviceChangeResParms, Val}, State) ->
1834
case enc_ServiceChangeResParm(Val, ?INC_INDENT(?INC_INDENT(State))) of
1839
?LBRKT_INDENT(State),
1847
end(?INC_INDENT(State)),
1848
?RBRKT_INDENT(State)
1851
enc_ServiceChangeResult({Tag, _}, _State) ->
1852
error({invalid_ServiceChangeResult_tag, Tag}).
1854
%% %% Required length of termination ID list is 1
1855
%% enc_TerminationIDList1({'TerminationIDList',Val}, State) ->
1856
%% enc_TerminationIDList1(Val, State);
1857
%% enc_TerminationIDList1([Singleton], State) ->
1858
%% enc_TerminationID(Singleton, State).
1860
%% No required length of termination ID list
1861
enc_TerminationIDList({'TerminationIDList',Val}, State) ->
1862
enc_TerminationIDList(Val, State);
1863
enc_TerminationIDList([TID], State) ->
1865
?LBRKT_INDENT(State),
1866
enc_TerminationID(TID, State),
1867
?RBRKT_INDENT(State)
1869
enc_TerminationIDList(TIDs, State) ->
1871
?LBRKT_INDENT(State),
1872
enc_list([{TIDs, fun enc_TerminationID/2}], State),
1873
?RBRKT_INDENT(State)
1876
enc_termIDList({'TerminationIDList',Val}, State) ->
1877
enc_termIDList(Val, State);
1878
enc_termIDList([Singleton], State) ->
1879
enc_TerminationID(Singleton, State);
1880
enc_termIDList(TidList, State)
1881
when is_list(TidList) and (length(TidList) > 1) ->
1882
%% d("enc_termIDList -> entry with"
1883
%% "~n TidList: ~p", [TidList]),
1884
State2 = ?INC_INDENT(State),
1886
?LSBRKT_INDENT(State),
1887
enc_list([{TidList, fun enc_TerminationID/2}], State2),
1888
?RSBRKT_INDENT(State)
1891
%% TerminationID = "ROOT" / pathNAME / "$" / "*"
1892
%% ; Total length of pathNAME must not exceed 64 chars.
1893
%% pathNAME = ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" )
1894
%% ["@" pathDomainName ]
1895
enc_TerminationID(Tid, State)
1896
when record(Tid, megaco_term_id) ->
1897
List = [{Tid#megaco_term_id.id, fun enc_tid_component/2 }],
1898
enc_list(List, State, fun(_S) -> ?SLASH end, false).
1900
enc_tid_component(Component, State) when list(Component) ->
1901
[enc_tid_sub_component(Sub, State) || Sub <- Component];
1902
enc_tid_component(Invalid, _State) ->
1903
error({invalid_id_list_component, Invalid}).
1905
enc_tid_sub_component(Sub, _State) ->
1908
choose -> ?megaco_choose;
1909
Char when integer(Char) -> Char
1912
%% mediaDescriptor = MediaToken LBRKT mediaParm *(COMMA mediaParm) RBRKT
1913
%% ; at-most-once per item
1914
%% ; and either streamParm or streamDescriptor but not both
1915
%% mediaParm = (streamParm / streamDescriptor /
1916
%% terminationStateDescriptor)
1918
%% streamParm = ( localDescriptor / remoteDescriptor /
1919
%% localControlDescriptor )
1920
%% streamDescriptor = StreamToken EQUAL StreamID LBRKT streamParm
1921
%% *(COMMA streamParm) RBRKT
1922
enc_MediaDescriptor(#'MediaDescriptor'{termStateDescr = TSD,
1923
streams = Streams}, State) ->
1926
?LBRKT_INDENT(State),
1927
enc_list([{[TSD], fun enc_TerminationStateDescriptor/2} |
1928
decompose_streams(Streams)],
1929
?INC_INDENT(State)),
1930
?RBRKT_INDENT(State)
1933
decompose_streams(asn1_NOVALUE) ->
1935
decompose_streams({'MediaDescriptor_streams',Val}) ->
1936
decompose_streams(Val);
1937
decompose_streams({Tag, Val}) ->
1940
decompose_StreamParms(Val);
1942
[{Val, fun enc_StreamDescriptor/2}];
1944
error({invalid_streams_tag, Tag})
1947
decompose_StreamParms(Val)
1948
when record(Val, 'StreamParms') ->
1950
{[Val#'StreamParms'.localControlDescriptor],
1951
fun enc_LocalControlDescriptor/2},
1952
{[Val#'StreamParms'.localDescriptor],
1953
fun enc_localDescriptor/2},
1954
{[Val#'StreamParms'.remoteDescriptor],
1955
fun enc_remoteDescriptor/2},
1956
{[Val#'StreamParms'.statisticsDescriptor],
1957
fun enc_StatisticsDescriptor/2}
1960
enc_StreamDescriptor(Val, State)
1961
when record(Val, 'StreamDescriptor') ->
1965
enc_StreamID(Val#'StreamDescriptor'.streamID, State),
1966
?LBRKT_INDENT(State),
1967
enc_list(decompose_StreamParms(Val#'StreamDescriptor'.streamParms),
1968
?INC_INDENT(State)),
1969
?RBRKT_INDENT(State)
1972
%% localControlDescriptor = LocalControlToken LBRKT localParm
1973
%% *(COMMA localParm) RBRKT
1975
%% ; at-most-once per item
1976
%% localParm = ( streamMode / propertyParm /
1977
%% reservedValueMode / reservedGroupMode )
1978
%% reservedValueMode = ReservedValueToken EQUAL ( "ON" / "OFF" )
1979
%% reservedGroupMode = ReservedGroupToken EQUAL ( "ON" / "OFF" )
1981
%% reservedMode = ReservedToken EQUAL ( "ON" / "OFF" )
1983
%% streamMode = ModeToken EQUAL streamModes
1984
enc_LocalControlDescriptor(
1985
#'LocalControlDescriptor'{streamMode = asn1_NOVALUE,
1986
reserveValue = asn1_NOVALUE,
1987
reserveGroup = asn1_NOVALUE,
1988
propertyParms = []}, _State) ->
1989
error({invalid_LocalControlDescriptor, empty});
1990
enc_LocalControlDescriptor(
1991
#'LocalControlDescriptor'{streamMode = SM,
1994
propertyParms = PPs}, State) ->
1997
?LBRKT_INDENT(State),
1998
enc_list([{[SM], fun enc_StreamMode/2},
1999
{[RG], fun enc_reservedGroupMode/2},
2000
{[RV], fun enc_reservedValueMode/2},
2001
{PPs, fun enc_PropertyParm/2}], ?INC_INDENT(State)),
2002
?RBRKT_INDENT(State)
2005
enc_reservedGroupMode(Val, _State) ->
2007
?ReservedGroupToken,
2015
enc_reservedValueMode(Val, _State) ->
2017
?ReservedValueToken,
2025
enc_StreamMode({'StreamMode',Val}, State) ->
2026
enc_StreamMode(Val, State);
2027
enc_StreamMode(Val, _State) ->
2032
sendOnly -> ?SendonlyToken;
2033
recvOnly -> ?RecvonlyToken;
2034
sendRecv -> ?SendrecvToken;
2035
inactive -> ?InactiveToken;
2036
loopBack -> ?LoopbackToken
2040
enc_Name({'Name',Val}, State) ->
2041
enc_Name(Val, State);
2042
enc_Name(Val, State) ->
2043
%% BUGBUG: NAME = ALPHA *63(ALPHA / DIGIT / "_" )
2044
enc_STRING(Val, State, 1, 64).
2046
enc_PkgdName({'PkgdName', Val}, State) ->
2047
enc_PkgdName(Val, State);
2048
enc_PkgdName(Val, State) ->
2049
%% BUGBUG: pkgdName = (NAME / "*") SLASH (ItemID / "*" )
2050
enc_OCTET_STRING(Val, State, 1, 64).
2052
enc_localDescriptor(Val, State)
2053
when record(Val, 'LocalRemoteDescriptor') ->
2057
enc_LocalRemoteDescriptor(Val, State),
2058
?RBRKT_INDENT(State)
2061
enc_remoteDescriptor(Val, State)
2062
when record(Val, 'LocalRemoteDescriptor') ->
2066
enc_LocalRemoteDescriptor(Val, State),
2067
?RBRKT_INDENT(State)
2070
%% When text encoding the protocol, the descriptors consist of session
2071
%% descriptions as defined in SDP (RFC2327), except that the "s=", "t="
2072
%% and "o=" lines are optional. When multiple session descriptions are
2073
%% provided in one descriptor, the "v=" lines are required as delimiters;
2074
%% otherwise they are optional. Implementations shall accept session
2075
%% descriptions that are fully conformant to RFC2327. When binary
2076
%% encoding the protocol the descriptor consists of groups of properties
2077
%% (tag-value pairs) as specified in Annex C. Each such group may
2078
%% contain the parameters of a session description.
2079
enc_LocalRemoteDescriptor(Val, State)
2080
when record(Val, 'LocalRemoteDescriptor') ->
2081
case Val#'LocalRemoteDescriptor'.propGrps of
2086
enc_PropertyGroup(OptV, opt_v, State) |
2087
[enc_PropertyGroup(M, mand_v, State) || M <- MandV]]
2090
enc_PropertyGroup({'PropertyGroup',Val}, RequiresV, State) ->
2091
enc_PropertyGroup(Val, RequiresV, State);
2092
enc_PropertyGroup([H | _T] = List, mand_v, State)
2093
when record(H, 'PropertyParm'), H#'PropertyParm'.name == "v" ->
2094
enc_PropertyGroup(List, opt_v, State);
2095
enc_PropertyGroup(PG, opt_v, State) ->
2097
[[enc_PropertyGroupParm(PP, State), ?CrToken, ?LfToken] || PP <- PG]
2100
enc_PropertyGroupParm(Val, State)
2101
when record(Val, 'PropertyParm') ->
2102
[OctetString] = Val#'PropertyParm'.value,
2104
enc_PkgdName(Val#'PropertyParm'.name, State),
2106
enc_OCTET_STRING(OctetString, State, 0, infinity)
2109
%% propertyParm = pkgdName parmValue
2110
%% parmValue = (EQUAL alternativeValue/ INEQUAL VALUE)
2111
%% alternativeValue = ( VALUE / LSBRKT VALUE *(COMMA VALUE) RSBRKT /
2112
%% LSBRKT VALUE DOT DOT VALUE RSBRKT )
2113
enc_PropertyParm(Val, State)
2114
when record(Val, 'PropertyParm') ->
2115
PkgdName = ?META_ENC(property, Val#'PropertyParm'.name),
2117
enc_PkgdName(PkgdName, State),
2118
enc_propertyParmValues(Val#'PropertyParm'.value,
2119
Val#'PropertyParm'.extraInfo,
2123
enc_propertyParmValues([Single], asn1_NOVALUE, State) ->
2126
enc_Value(Single, State)
2128
enc_propertyParmValues([Single], {relation, Rel}, State) ->
2130
greaterThan -> [$>, enc_Value(Single, State)];
2131
smallerThan -> [$<, enc_Value(Single, State)];
2132
unequalTo -> [$#, enc_Value(Single, State)]
2134
enc_propertyParmValues([Low, High], {range, true}, State)->
2139
enc_Value(Low, State),
2141
enc_Value(High, State),
2144
enc_propertyParmValues(Values, {sublist, true}, State)->
2145
%% sublist (i.e. A AND B AND ...)
2148
?LSBRKT_INDENT(State),
2149
enc_list([{Values, fun enc_Value/2}], ?INC_INDENT(State)),
2150
?RSBRKT_INDENT(State)
2152
enc_propertyParmValues(Values, {sublist, false}, State) ->
2153
%% alternatives (i.e. A OR B OR ...)
2156
?LBRKT_INDENT(State),
2157
enc_list([{Values, fun enc_Value/2}], ?INC_INDENT(State)),
2158
?RBRKT_INDENT(State)
2160
enc_propertyParmValues(V, EI, _State) ->
2161
error({invalid_property_parm_values, V, EI}).
2163
enc_TerminationStateDescriptor(Val, State)
2164
when record(Val, 'TerminationStateDescriptor') ->
2166
?TerminationStateToken,
2167
?LBRKT_INDENT(State),
2168
enc_list([{Val#'TerminationStateDescriptor'.propertyParms,
2169
fun enc_PropertyParm/2},
2170
{[Val#'TerminationStateDescriptor'.eventBufferControl],
2171
fun enc_eventBufferControl/2},
2172
{[Val#'TerminationStateDescriptor'.serviceState],
2173
fun enc_serviceState/2}],
2174
?INC_INDENT(State)),
2175
?RBRKT_INDENT(State)
2178
enc_eventBufferControl(Val, _State) ->
2185
lockStep -> ?LockStepToken
2189
enc_serviceState({'ServiceState',Val}, State) ->
2190
enc_serviceState(Val, State);
2191
enc_serviceState(Val, _State) ->
2193
?ServiceStatesToken,
2197
outOfSvc -> ?OutOfSvcToken;
2198
inSvc -> ?InSvcToken
2202
enc_MuxDescriptor(Val, State)
2203
when record(Val, 'MuxDescriptor') ->
2207
enc_MuxType(Val#'MuxDescriptor'.muxType, State),
2208
enc_TerminationIDList(Val#'MuxDescriptor'.termList, State)
2211
enc_MuxType({'MuxType',Val}, State) ->
2212
enc_MuxType(Val, State);
2213
enc_MuxType(Val, _State) ->
2219
%% extensionParameter
2220
nx64k -> ?Nx64kToken % v2
2223
enc_StreamID({'StreamID',Val}, State) ->
2224
enc_StreamID(Val, State);
2225
enc_StreamID(Val, State) ->
2226
enc_UINT16(Val, State).
2228
enc_EventsDescriptor(#'EventsDescriptor'{requestID = asn1_NOVALUE,
2229
eventList = []}, _State) ->
2233
enc_EventsDescriptor(#'EventsDescriptor'{requestID = RID,
2234
eventList = Evs}, State)
2235
when (RID =/= asn1_NOVALUE) and (Evs =/= []) ->
2239
enc_RequestID(RID, State),
2240
?LBRKT_INDENT(State),
2241
enc_list([{Evs, fun enc_RequestedEvent/2}], ?INC_INDENT(State)),
2242
?RBRKT_INDENT(State)
2244
enc_EventsDescriptor(#'EventsDescriptor'{requestID = RID,
2245
eventList = Evs}, _State) ->
2246
error({invalid_EventsDescriptor, RID, Evs}).
2248
enc_RequestedEvent(#'RequestedEvent'{pkgdName = N,
2249
streamID = asn1_NOVALUE,
2250
eventAction = asn1_NOVALUE,
2251
evParList = []}, State) ->
2252
PkgdName = ?META_ENC(event, N),
2254
enc_PkgdName(PkgdName, State)
2256
enc_RequestedEvent(#'RequestedEvent'{pkgdName = N,
2259
evParList = EPL}, State) ->
2260
PkgdName = ?META_ENC(event, N),
2262
enc_PkgdName(PkgdName, State),
2263
?LBRKT_INDENT(State),
2264
enc_list([{[SID], fun enc_eventStream/2},
2265
{EPL, fun enc_eventOther/2} |
2266
decompose_requestedActions(EA)],
2267
?INC_INDENT(State)),
2268
?RBRKT_INDENT(State)
2271
decompose_requestedActions(asn1_NOVALUE) ->
2273
decompose_requestedActions(
2274
#'RequestedActions'{keepActive = asn1_NOVALUE,
2275
eventDM = asn1_NOVALUE,
2276
secondEvent = asn1_NOVALUE,
2277
signalsDescriptor = asn1_NOVALUE,
2278
notifyBehaviour = asn1_NOVALUE,
2279
resetEventsDescriptor = asn1_NOVALUE}) ->
2283
%% This in the ABNF:
2284
%% at-most-once each of
2285
%% - KeepActiveToken
2286
%% - notifyBehaviour
2288
%% - ResetEventsDescriptor
2290
%% at most one of either embedWithSig or embedNoSig but not both
2291
%% KeepActiveToken and embedWithSig must not both be present
2295
decompose_requestedActions(#'RequestedActions'{keepActive = KA,
2298
signalsDescriptor = SD,
2299
notifyBehaviour = NB,
2300
resetEventsDescriptor = RED})
2301
when (KA =/= true) and ((SD =/= asn1_NOVALUE) and (SD =/= [])) ->
2303
{[EDM], fun enc_EventDM/2},
2304
{[{SE, SD}], fun enc_embedWithSig/2},
2305
{[NB], fun enc_notifyBehaviour/2},
2306
{[RED], fun('NULL', _) -> ?ResetEventsDescriptorToken end}
2310
decompose_requestedActions(#'RequestedActions'{keepActive = KA,
2313
signalsDescriptor = SD,
2314
notifyBehaviour = NB,
2315
resetEventsDescriptor = RED})
2316
when (SD == asn1_NOVALUE) or (SD == []) ->
2318
{[KA], fun enc_keepActive/2},
2319
{[EDM], fun enc_EventDM/2},
2320
{[SE], fun enc_embedNoSig/2},
2321
{[NB], fun enc_notifyBehaviour/2},
2322
{[RED], fun('NULL', _) -> ?ResetEventsDescriptorToken end}
2325
%% Fallback, if everything else failes....
2326
decompose_requestedActions(#'RequestedActions'{keepActive = KA,
2329
signalsDescriptor = SD,
2330
notifyBehaviour = NB,
2331
resetEventsDescriptor = RED}) ->
2333
{[KA], fun enc_keepActive/2},
2334
{[EDM], fun enc_EventDM/2},
2335
{[{SE, SD}], fun enc_embedWithSig/2},
2336
{[NB], fun enc_notifyBehaviour/2},
2337
{[RED], fun('NULL', _) -> ?ResetEventsDescriptorToken end}
2341
enc_embedNoSig(#'SecondEventsDescriptor'{requestID = RID,
2342
eventList = Evs}, State) ->
2345
?LBRKT_INDENT(State),
2346
enc_embedFirst(RID, Evs, ?INC_INDENT(State)),
2347
?RBRKT_INDENT(State)
2350
enc_embedWithSig({asn1_NOVALUE, SD}, State) ->
2353
?LBRKT_INDENT(State),
2354
enc_SignalsDescriptor(SD, ?INC_INDENT(State)),
2355
?RBRKT_INDENT(State)
2357
enc_embedWithSig({#'SecondEventsDescriptor'{requestID = RID,
2358
eventList = Evs}, SD}, State) ->
2361
?LBRKT_INDENT(State),
2362
enc_SignalsDescriptor(SD, ?INC_INDENT(State)),
2363
?COMMA_INDENT(?INC_INDENT(State)),
2364
enc_embedFirst(RID, Evs, ?INC_INDENT(State)),
2365
?RBRKT_INDENT(State)
2368
enc_keepActive(Val, _State) ->
2370
true -> [?KeepActiveToken];
2374
enc_EventDM({'EventDM',Val}, State) ->
2375
enc_EventDM(Val, State);
2376
enc_EventDM({Tag, Val}, State) ->
2382
enc_DigitMapName(Val, State)
2387
?LBRKT_INDENT(State),
2388
enc_DigitMapValue(Val, ?INC_INDENT(State)),
2389
?RBRKT_INDENT(State)
2392
error({invalid_EventDM_tag, Tag})
2396
enc_embedFirst(RID, Evs, State)
2397
when (RID =/= asn1_NOVALUE) and (is_list(Evs) and (Evs =/= [])) ->
2398
%% d("enc_embedFirst -> entry with"
2400
%% "~n Evs: ~p", [RID, Evs]),
2404
enc_RequestID(RID, State),
2405
?LBRKT_INDENT(State),
2406
enc_list([{Evs, fun enc_SecondRequestedEvent/2}], ?INC_INDENT(State)),
2407
?RBRKT_INDENT(State)
2409
enc_embedFirst(_RID, _Evs, _State) ->
2410
%% d("enc_embedFirst -> entry"),
2415
enc_notifyBehaviour({notifyImmediate, 'NULL'}, _State) ->
2416
[?NotifyImmediateToken];
2417
enc_notifyBehaviour({notifyRegulated, Val}, State) ->
2418
enc_RegulatedEmbeddedDescriptor(Val, State);
2419
enc_notifyBehaviour({neverNotify, 'NULL'}, _State) ->
2420
[?NeverNotifyToken];
2421
enc_notifyBehaviour({Tag, Val}, _State) ->
2422
error({invalid_notifyBehaviour, Tag, Val}).
2424
enc_RegulatedEmbeddedDescriptor(
2425
#'RegulatedEmbeddedDescriptor'{secondEvent = asn1_NOVALUE,
2426
signalsDescriptor = asn1_NOVALUE}, _State) ->
2428
?NotifyRegulatedToken
2430
enc_RegulatedEmbeddedDescriptor(
2431
#'RegulatedEmbeddedDescriptor'{secondEvent = SE,
2432
signalsDescriptor = asn1_NOVALUE}, State) ->
2434
?NotifyRegulatedToken,
2435
?LBRKT_INDENT(State),
2436
enc_embedNoSig(SE, ?INC_INDENT(State)),
2437
?RBRKT_INDENT(State)
2439
enc_RegulatedEmbeddedDescriptor(
2440
#'RegulatedEmbeddedDescriptor'{secondEvent = SE,
2441
signalsDescriptor = SD}, State) ->
2443
?NotifyRegulatedToken,
2444
?LBRKT_INDENT(State),
2445
enc_embedWithSig({SE, SD}, ?INC_INDENT(State)),
2446
?RBRKT_INDENT(State)
2448
enc_RegulatedEmbeddedDescriptor(Val, _State) ->
2449
error({invalid_RegulatedEmbeddedDescriptor, Val}).
2451
enc_SecondRequestedEvent(#'SecondRequestedEvent'{pkgdName = N,
2452
streamID = asn1_NOVALUE,
2453
eventAction = asn1_NOVALUE,
2454
evParList = []}, State) ->
2455
PkgdName = ?META_ENC(event, N),
2457
enc_PkgdName(PkgdName, State)
2459
enc_SecondRequestedEvent(#'SecondRequestedEvent'{pkgdName = N,
2462
evParList = EPL}, State) ->
2463
PkgdName = ?META_ENC(event, N),
2465
enc_PkgdName(PkgdName, State),
2466
?LBRKT_INDENT(State),
2467
enc_list([{[SID], fun enc_eventStream/2},
2468
{EPL, fun enc_eventOther/2} |
2469
decompose_secondRequestedActions(EA)],
2470
?INC_INDENT(State)),
2471
?RBRKT_INDENT(State)
2475
%% This in the ABNF:
2476
%% at-most-once each of
2477
%% - KeepActiveToken
2478
%% - notifyBehaviour
2480
%% - ResetEventsDescriptor
2482
%% KeepActiveToken and embedWithSig must not both be present
2484
decompose_secondRequestedActions(asn1_NOVALUE) ->
2486
decompose_secondRequestedActions(
2487
#'SecondRequestedActions'{keepActive = asn1_NOVALUE,
2488
eventDM = asn1_NOVALUE,
2489
signalsDescriptor = asn1_NOVALUE,
2490
notifyBehaviour = asn1_NOVALUE,
2491
resetEventsDescriptor = asn1_NOVALUE}) ->
2494
decompose_secondRequestedActions(
2495
#'SecondRequestedActions'{keepActive = KA,
2497
signalsDescriptor = SD,
2498
notifyBehaviour = NB,
2499
resetEventsDescriptor = RED})
2500
when (KA =/= true) and ((SD =/= asn1_NOVALUE) and (SD =/= [])) ->
2502
{[EDM], fun enc_EventDM/2},
2503
{[SD], fun enc_embedSig/2},
2504
{[NB], fun enc_notifyBehaviour/2},
2505
{[RED], fun('NULL', _) -> ?ResetEventsDescriptorToken end}
2507
decompose_secondRequestedActions(
2508
#'SecondRequestedActions'{keepActive = KA,
2510
signalsDescriptor = SD,
2511
notifyBehaviour = NB,
2512
resetEventsDescriptor = RED})
2513
when (SD == asn1_NOVALUE) or (SD == []) ->
2515
{[KA], fun enc_keepActive/2},
2516
{[EDM], fun enc_EventDM/2},
2517
{[NB], fun enc_notifyBehaviour/2},
2518
{[RED], fun('NULL', _) -> ?ResetEventsDescriptorToken end}
2520
decompose_secondRequestedActions(SRA) ->
2521
error({invalid_SecondRequestedActions, SRA}).
2523
enc_embedSig(Val, State) ->
2526
?LBRKT_INDENT(State),
2527
enc_SignalsDescriptor(Val, ?INC_INDENT(State)),
2528
?RBRKT_INDENT(State)
2531
enc_EventBufferDescriptor({'EventBufferDescriptor',Val}, State) ->
2532
enc_EventBufferDescriptor(Val, State);
2533
enc_EventBufferDescriptor([], _State) ->
2537
enc_EventBufferDescriptor(EvSpecs, State) when is_list(EvSpecs) ->
2540
?LBRKT_INDENT(State),
2541
enc_eventSpecs(EvSpecs, ?INC_INDENT(State)),
2542
?RBRKT_INDENT(State)
2545
enc_eventSpecs([Mand | Opt], State) ->
2546
[enc_eventSpecs(Mand, State),
2547
[[?COMMA_INDENT(State), enc_eventSpec(Val, State)] || Val <- Opt]].
2549
enc_eventSpec(#'EventSpec'{eventName = N,
2550
streamID = asn1_NOVALUE,
2551
eventParList = []}, State) ->
2553
enc_EventName(N, State)
2555
enc_eventSpec(#'EventSpec'{eventName = N,
2557
eventParList = EPL}, State) ->
2559
enc_EventName(N, State),
2560
?LBRKT_INDENT(State),
2561
enc_list([{[SID], fun enc_eventStream/2}, {EPL, fun enc_eventOther/2}],
2562
?INC_INDENT(State)),
2563
?RBRKT_INDENT(State)
2566
enc_SignalsDescriptor({'SignalsDescriptor',Val}, State) ->
2567
enc_SignalsDescriptor(Val, State);
2568
enc_SignalsDescriptor([], _State) ->
2572
enc_SignalsDescriptor(SigRequests, State) when is_list(SigRequests) ->
2575
?LBRKT_INDENT(State),
2576
enc_list([{SigRequests, fun enc_SignalRequest/2}], ?INC_INDENT(State)),
2577
?RBRKT_INDENT(State)
2580
enc_SignalRequest({'SignalRequest',Val}, State) ->
2581
enc_SignalRequest(Val, State);
2582
enc_SignalRequest({Tag, Val}, State) ->
2585
enc_Signal(Val, State);
2587
enc_SeqSigList(Val, State);
2589
error({invalid_SignalRequest_tag, Tag})
2593
enc_SeqSigList(Val, State)
2594
when record(Val, 'SeqSigList') ->
2598
enc_UINT16(Val#'SeqSigList'.id, State),
2599
?LBRKT_INDENT(State),
2600
enc_list([{Val#'SeqSigList'.signalList, fun enc_Signal/2}],
2601
?INC_INDENT(State)),
2602
?RBRKT_INDENT(State)
2605
enc_Signal(#'Signal'{signalName = SN,
2609
notifyCompletion = NC,
2614
intersigDelay = ISD}, State) ->
2616
enc_SignalName(SN, State),
2618
enc_list([{[SID], fun enc_sigStream/2},
2619
{[ST], fun enc_sigSignalType/2},
2620
{[Du], fun enc_sigDuration/2},
2621
{[NC], fun enc_notifyCompletion/2},
2622
{[KA], fun enc_keepActive/2},
2623
{SPL, fun enc_sigOther/2},
2624
{[Di], fun enc_SignalDirection/2},
2625
{[RID], fun enc_sigRequestID/2},
2626
{[ISD], fun enc_sigIntsigDelay/2}],
2627
?INC_INDENT(State)),
2631
enc_sigStream(Val, State) ->
2635
enc_StreamID(Val, State)
2638
enc_sigSignalType(Val, State) ->
2642
enc_SignalType(Val, State)
2645
enc_sigDuration(Val, State) ->
2649
enc_UINT16(Val, State)
2652
enc_notifyCompletion(List, State) when list(List) ->
2654
?NotifyCompletionToken,
2656
?LBRKT_INDENT(State),
2657
enc_list([{List, fun enc_notifyCompletionItem/2}], ?INC_INDENT(State)),
2658
?RBRKT_INDENT(State)
2661
enc_notifyCompletionItem(Val, _State) ->
2663
onTimeOut -> ?TimeOutToken;
2664
onInterruptByEvent -> ?InterruptByEventToken;
2665
onInterruptByNewSignalDescr -> ?InterruptByNewSignalsDescrToken;
2666
otherReason -> ?OtherReasonToken;
2667
onIteration -> ?IterationToken
2670
enc_SignalType({'SignalType',Val}, State) ->
2671
enc_SignalType(Val, State);
2672
enc_SignalType(Val, _State) ->
2674
brief -> ?BriefToken;
2675
onOff -> ?OnOffToken;
2676
timeOut -> ?TimeOutToken
2679
enc_SignalName({'SignalName',Val}, State)->
2680
enc_SignalName(Val, State);
2681
enc_SignalName(Val, State) ->
2682
PkgdName = ?META_ENC(signal, Val),
2683
enc_PkgdName(PkgdName, State).
2685
enc_sigOther(Val, State)
2686
when record(Val, 'SigParameter') ->
2688
enc_Name(Val#'SigParameter'.sigParameterName, State),
2689
enc_propertyParmValues(Val#'SigParameter'.value,
2690
Val#'SigParameter'.extraInfo,
2694
enc_SignalDirection({'SignalDirection', Val}, State) ->
2695
enc_SignalDirection(Val, State);
2696
enc_SignalDirection(Val, _State) ->
2701
internal -> ?InternalToken;
2702
external -> ?ExternalToken;
2707
enc_sigRequestID(Val, State) ->
2711
enc_RequestID(Val, State)
2714
enc_RequestID({'RequestID',Val}, State) ->
2715
enc_RequestID(Val, State);
2716
enc_RequestID(Val, _State) when Val == ?megaco_all_request_id ->
2718
enc_RequestID(Val, State) ->
2719
enc_UINT32(Val, State).
2721
enc_sigIntsigDelay(Val, State) ->
2725
enc_UINT16(Val, State)
2728
enc_ModemDescriptor(MD, _State) ->
2729
error({deprecated, MD}).
2732
%% As of corr 1 ModemDescriptor has been deprecated.
2733
%% 7.1.2: ...shall not be included as part of a transmitted content and,
2734
%% if received, shall either be ignored or processed at the option
2735
%% of the implementation. ...
2736
%% enc_ModemDescriptor(#'ModemDescriptor'{mtl = [Val],
2738
%% nonStandardData = asn1_NOVALUE},
2743
%% enc_ModemType(Val, State)
2745
%% enc_ModemDescriptor(Val, State)
2746
%% when record(Val, 'ModemDescriptor') ->
2750
%% enc_list([{Val#'ModemDescriptor'.mtl, fun enc_ModemType/2}], State),
2752
%% enc_opt_brackets(
2753
%% enc_list([{Val#'ModemDescriptor'.mpl, fun enc_PropertyParm/2}],
2754
%% ?INC_INDENT(State)),
2756
%% %% BUGBUG: Is PropertyParm == NAME parmValue?
2759
%% enc_ModemDescriptor(Val, State)
2760
%% when record(Val, 'ModemDescriptor') ->
2763
%% %% BUGBUG: Does never generate: EQUAL modemType
2765
%% enc_list([{Val#'ModemDescriptor'.mtl, fun enc_ModemType/2}], State),
2767
%% enc_opt_brackets(
2768
%% enc_list([{Val#'ModemDescriptor'.mpl, fun enc_PropertyParm/2}],
2769
%% ?INC_INDENT(State)),
2771
%% %% BUGBUG: Is PropertyParm == NAME parmValue?
2774
%% Corr1: See ModemDescriptor above
2775
%% enc_ModemType({'ModemType',Val}, State)->
2776
%% enc_ModemType(Val, State);
2777
%% enc_ModemType(Val, _State) ->
2778
%% %% BUGBUG: Does not handle extensionParameter
2780
%% v18 -> ?V18Token;
2781
%% v22 -> ?V22Token;
2782
%% v22bis -> ?V22bisToken;
2783
%% v32 -> ?V32Token;
2784
%% v32bis -> ?V32bisToken;
2785
%% v34 -> ?V34Token;
2786
%% v90 -> ?V90Token;
2787
%% v91 -> ?V91Token;
2788
%% synchISDN -> ?SynchISDNToken
2791
enc_DigitMapDescriptor(Val, State)
2792
when record(Val, 'DigitMapDescriptor') ->
2796
enc_DigitMapName(Val#'DigitMapDescriptor'.digitMapName, State),
2797
?LBRKT_INDENT(State),
2798
enc_DigitMapValue(Val#'DigitMapDescriptor'.digitMapValue,
2799
?INC_INDENT(State)),
2800
?RBRKT_INDENT(State)
2803
enc_DigitMapName({'DigitMapName',Val}, State) ->
2804
enc_DigitMapName(Val, State);
2805
enc_DigitMapName(Val, State) ->
2806
enc_Name(Val, State).
2808
enc_DigitMapValue(Val, State)
2809
when record(Val, 'DigitMapValue') ->
2811
enc_timer(Val#'DigitMapValue'.startTimer, $T, State),
2812
enc_timer(Val#'DigitMapValue'.shortTimer, $S, State),
2813
enc_timer(Val#'DigitMapValue'.longTimer, $L, State),
2814
enc_timer(Val#'DigitMapValue'.durationTimer, $Z, State),
2815
%% BUGBUG: digitMapBody not handled at all
2816
enc_STRING(Val#'DigitMapValue'.digitMapBody, State, 0, infinity)
2819
enc_timer(asn1_NOVALUE, _Prefix, _State) ->
2821
enc_timer(Timer, Prefix, State) ->
2825
enc_DIGIT(Timer, State, 0, 99),
2826
?COMMA_INDENT(State)
2829
enc_ServiceChangeParm(Val, State)
2830
when record(Val, 'ServiceChangeParm') ->
2833
?LBRKT_INDENT(State),
2834
enc_list([{[Val#'ServiceChangeParm'.serviceChangeMethod],
2835
fun enc_ServiceChangeMethod/2},
2836
{[Val#'ServiceChangeParm'.serviceChangeAddress],
2837
fun enc_ServiceChangeAddress/2},
2838
{[Val#'ServiceChangeParm'.serviceChangeVersion],
2839
fun enc_serviceChangeVersion/2},
2840
{[Val#'ServiceChangeParm'.serviceChangeProfile],
2841
fun enc_ServiceChangeProfile/2},
2842
{[{reason, Val#'ServiceChangeParm'.serviceChangeReason}],
2843
fun enc_serviceChangeReason/2},
2844
{[Val#'ServiceChangeParm'.serviceChangeDelay],
2845
fun enc_serviceChangeDelay/2},
2846
{[Val#'ServiceChangeParm'.serviceChangeMgcId],
2847
fun enc_serviceChangeMgcId/2},
2848
{[Val#'ServiceChangeParm'.timeStamp],
2849
fun enc_TimeNotation/2},
2850
{Val#'ServiceChangeParm'.serviceChangeInfo,
2851
fun enc_AuditDescriptor/2},
2852
{[Val#'ServiceChangeParm'.serviceChangeIncompleteFlag],
2853
fun('NULL', _) -> ?ServiceChangeIncompleteToken end}],
2854
?INC_INDENT(State)),
2855
?RBRKT_INDENT(State)
2859
enc_ServiceChangeMethod({'ServiceChangeMethod',Val}, State) ->
2860
enc_ServiceChangeMethod(Val, State);
2861
enc_ServiceChangeMethod(Val, _State) ->
2866
failover -> ?FailoverToken;
2867
forced -> ?ForcedToken;
2868
graceful -> ?GracefulToken;
2869
restart -> ?RestartToken;
2870
disconnected -> ?DisconnectedToken;
2871
handOff -> ?HandOffToken;
2873
error({invalid_ServiceChangeMethod, Val})
2878
enc_ServiceChangeAddress({'ServiceChangeAddress',Val}, State) ->
2879
enc_ServiceChangeAddress(Val, State);
2880
enc_ServiceChangeAddress({Tag, Val}, State) ->
2882
?ServiceChangeAddressToken,
2886
enc_portNumber(Val, State);
2888
enc_IP4Address(Val, State);
2890
enc_IP6Address(Val, State);
2892
enc_DomainName(Val, State);
2894
enc_PathName(Val, State);
2896
enc_mtpAddress(Val, State);
2898
error({invalid_ServiceChangeAddress_tag, Tag})
2902
enc_serviceChangeVersion(Val, State) ->
2906
enc_version(Val, State)
2909
enc_ServiceChangeProfile(#'ServiceChangeProfile'{profileName = Name,
2915
enc_Name(Name, State),
2917
enc_version(Version, State)
2920
enc_serviceChangeReason({reason, Val}, State) ->
2924
[List] when list(List) ->
2928
enc_QUOTED_STRING(List,State) % OTP-4632 enc_Value(List, State)
2932
enc_serviceChangeDelay(Val, State) ->
2936
enc_UINT32(Val, State)
2939
enc_serviceChangeMgcId(Val, State) ->
2946
enc_portNumber(Val, State) when integer(Val), Val >= 0 ->
2947
enc_UINT16(Val, State).
2949
enc_ServiceChangeResParm(Val, State)
2950
when record(Val, 'ServiceChangeResParm') ->
2951
enc_list([{[Val#'ServiceChangeResParm'.serviceChangeAddress],
2952
fun enc_ServiceChangeAddress/2},
2953
{[Val#'ServiceChangeResParm'.serviceChangeVersion],
2954
fun enc_serviceChangeVersion/2},
2955
{[Val#'ServiceChangeResParm'.serviceChangeProfile],
2956
fun enc_ServiceChangeProfile/2},
2957
{[Val#'ServiceChangeResParm'.serviceChangeMgcId],
2958
fun enc_serviceChangeMgcId/2},
2959
{[Val#'ServiceChangeResParm'.timeStamp],
2960
fun enc_TimeNotation/2}],
2963
enc_PackagesDescriptor({'PackagesDescriptor',Val}, State) ->
2964
enc_PackagesDescriptor(Val, State);
2965
enc_PackagesDescriptor(Val, State) ->
2968
?LBRKT_INDENT(State),
2969
enc_list([{Val, fun enc_PackagesItem/2}], ?INC_INDENT(State)),
2970
?RBRKT_INDENT(State)
2973
enc_PackagesItem(Val, State)
2974
when record(Val, 'PackagesItem') ->
2975
PkgdName = ?META_ENC(package, Val#'PackagesItem'.packageName),
2977
enc_Name(PkgdName, State),
2979
enc_UINT16(Val#'PackagesItem'.packageVersion, State)
2982
enc_StatisticsDescriptor({'StatisticsDescriptor',Val}, State) ->
2983
enc_StatisticsDescriptor(Val, State);
2984
enc_StatisticsDescriptor(List, State) when list(List) ->
2987
?LBRKT_INDENT(State),
2988
enc_list([{List, fun enc_StatisticsParameter/2}], ?INC_INDENT(State)),
2989
?RBRKT_INDENT(State)
2992
enc_StatisticsParameter(Val, State)
2993
when record(Val, 'StatisticsParameter') ->
2994
PkgdName = ?META_ENC(statistics, Val#'StatisticsParameter'.statName),
2995
case Val#'StatisticsParameter'.statValue of
2998
enc_PkgdName(PkgdName, State)
3000
[StatVal] when list(StatVal) ->
3002
enc_PkgdName(PkgdName, State),
3004
enc_Value(StatVal, State)
3008
enc_TimeNotation(Val, State)
3009
when record(Val, 'TimeNotation') ->
3011
enc_STRING(Val#'TimeNotation'.date, State, 8, 8), % "yyyymmdd"
3013
enc_STRING(Val#'TimeNotation'.time, State, 8, 8) % "hhmmssss"
3016
%% BUGBUG: Does not verify that string must contain at least one char
3017
%% BUGBUG: This violation of the is required in order to comply with
3018
%% BUGBUG: the dd/ce ds parameter that may possibly be empty.
3019
enc_Value({'Value',Val}, State) ->
3020
enc_Value(Val, State);
3021
enc_Value(String, _State) ->
3022
case quoted_string_count(String, 0, true) of
3024
[?DQUOTE, String, ?DQUOTE];
3026
[?DQUOTE, String, ?DQUOTE];
3031
quoted_string_count([H | T], Count, IsSafe) ->
3032
case ?classify_char(H) of
3033
safe_char -> quoted_string_count(T, Count + 1, IsSafe);
3034
rest_char -> quoted_string_count(T, Count + 1, false);
3035
white_space -> quoted_string_count(T, Count + 1, false);
3036
_ -> error({illegal_char, H})
3038
quoted_string_count([], Count, IsSafe) ->
3041
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3043
%% Encode an octet string, escape } by \ if necessary
3044
enc_OCTET_STRING(List, State, Min, Max) ->
3045
do_enc_OCTET_STRING(List, State, Min, Max, 0).
3047
do_enc_OCTET_STRING([H | T], State, Min, Max, Count) ->
3050
[$\\, H | do_enc_OCTET_STRING(T, State, Min, Max, Count + 1)];
3052
[H | do_enc_OCTET_STRING(T, State, Min, Max, Count + 1)]
3054
do_enc_OCTET_STRING([], _State, Min, Max, Count) ->
3055
verify_count(Count, Min, Max),
3058
enc_QUOTED_STRING(String, _State) when list(String) ->
3059
{_IsSafe, Count} = quoted_string_count(String, 0, true),
3060
verify_count(Count, 1, infinity),
3061
[?DQUOTE, String, ?DQUOTE].
3063
%% The internal format of hex digits is a list of octets
3064
%% Min and Max means #hexDigits
3065
%% Leading zeros are prepended in order to fulfill Min
3066
enc_HEXDIG(Octets, State, Min, Max) when list(Octets) ->
3067
do_enc_HEXDIG(Octets, State, Min, Max, 0, []).
3069
do_enc_HEXDIG([Octet | Rest], State, Min, Max, Count, Acc)
3070
when Octet >= 0, Octet =< 255 ->
3071
Hex = hex(Octet), % OTP-4921
3074
Acc2 = [[$0|Hex]|Acc], % OTP-4921
3075
do_enc_HEXDIG(Rest, State, Min, Max, Count + 2, ["0" | Acc2]);
3077
Acc2 = [Hex|Acc], % OTP-4921
3078
do_enc_HEXDIG(Rest, State, Min, Max, Count + 2, Acc2)
3080
do_enc_HEXDIG([], State, Min, Max, Count, Acc)
3081
when integer(Min), Count < Min ->
3082
do_enc_HEXDIG([0], State, Min, Max, Count, Acc);
3083
do_enc_HEXDIG([], _State, Min, Max, Count, Acc) -> %% OTP-4710
3084
verify_count(Count, Min, Max),
3087
enc_DIGIT(Val, State, Min, Max) ->
3088
enc_integer(Val, State, Min, Max).
3090
enc_STRING(String, _State, Min, Max) when list(String) ->
3091
verify_count(length(String), Min, Max),
3094
enc_UINT16(Val, State) ->
3095
enc_integer(Val, State, 0, 65535).
3097
enc_UINT32(Val, State) ->
3098
enc_integer(Val, State, 0, 4294967295).
3100
enc_integer(Val, _State, Min, Max) ->
3101
verify_count(Val, Min, Max),
3102
integer_to_list(Val).
3104
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3105
%% Encodes a list of elements with separator tokens between
3106
%% the elements. Optional asn1_NOVALUE values are ignored.
3108
enc_list(asn1_NOVALUE, _State) ->
3110
enc_list([], _State) ->
3112
enc_list(List, State) ->
3113
enc_list(List, State, fun(_S) -> ?COMMA_INDENT(_S) end, false).
3115
enc_list([], _State, _SepEncoder, _NeedsSep) ->
3117
enc_list([{Elems, ElemEncoder} | Tail], State, SepEncoder, NeedsSep) ->
3118
%% d("enc_list -> entry with"
3120
%% "~n ElemEncoder: ~p"
3121
%% "~n State: ~p", [Elems, ElemEncoder, State]),
3122
case do_enc_list(Elems, State, ElemEncoder, SepEncoder, NeedsSep) of
3124
enc_list(Tail, State, SepEncoder, NeedsSep);
3127
enc_list(Tail, State, SepEncoder, true)]
3129
enc_list(A, B, C, D) ->
3130
error({invalid_list, A, B, C, D}).
3132
do_enc_list(asn1_NOVALUE, _State, _ElemEncoder, _SepEncoder, _NeedsSep) ->
3134
do_enc_list([], _State, _ElemEncoder, _SepEncoder, _NeedsSep) ->
3136
do_enc_list([asn1_NOVALUE | T], State, ElemEncoder, SepEncoder, NeedsSep) ->
3137
do_enc_list(T, State, ElemEncoder, SepEncoder, NeedsSep);
3138
do_enc_list([H | T], State, ElemEncoder, SepEncoder, NeedsSep)
3139
when function(ElemEncoder), function(SepEncoder) ->
3140
case ElemEncoder(H, State) of
3142
do_enc_list(T, State, ElemEncoder, SepEncoder, NeedsSep);
3143
List when NeedsSep == true ->
3145
List, do_enc_list(T, State, ElemEncoder, SepEncoder, true)];
3146
List when NeedsSep == false ->
3148
do_enc_list(T, State, ElemEncoder, SepEncoder, true)]
3151
%% Add brackets if list is non-empty
3152
enc_opt_brackets([], _State) ->
3154
enc_opt_brackets(List, _State) when list(List) ->
3155
[?LBRKT_INDENT(_State), List, ?RBRKT_INDENT(_State)].
3157
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3159
%% Int -> list of hex chars
3161
hexi(get_lo_bits(Int, 4), []).
3163
hexi({0, Lo}, Ack) ->
3165
hexi({Hi, Lo} , Ack) ->
3166
hexi(get_lo_bits(Hi, 4), [hex4(Lo) | Ack]).
3168
hex4(Int) when Int < 10 ->
3173
get_lo_bits(Int, Size) ->
3174
Lo = Int band ones_mask(Size),
3181
%% Verify that Count is within the range of Min and Max
3182
verify_count(Count, Min, Max) ->
3186
integer(Min), Count >= Min ->
3188
integer(Max), Count =< Max ->
3193
error({count_too_large, Count, Max})
3196
error({count_too_small, Count, Min})
3199
error({count_not_an_integer, Count})
3202
%% -------------------------------------------------------------------
3205
erlang:error(Reason).
3208
%% -------------------------------------------------------------------
3213
%% d(get(dbg), F, A).
3216
%% io:format("~p:" ++ F ++ "~n", [?MODULE | A]);
added
removed
lib/megaco/src/text/megaco_text_gen_prev3c.hrl
