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 V2 Megaco/H.248 text messages from internal form
20
%% The following was changed:
21
%% - MuxType (Nx64kToken)
22
%% - auditItem (terminationAudit)
23
%% - serviceChangeParm (auditItem)
25
%% The following was added:
27
%%----------------------------------------------------------------------
29
%% -define(d(F,A), io:format("~w:" ++ F ++ "~n", [?MODULE|A])).
31
-define(META_ENC(Type, Item), Item) .
32
%% -define(META_ENC(Type, Item), megaco_meta_package:encode(text, Type, Item)).
33
%% -define(META_DEC(Type, Item), megaco_meta_package:decode(text, Type, Item)).
35
enc_MegacoMessage(Val) ->
37
enc_MegacoMessage(Val, State).
39
enc_MegacoMessage(Val, State)
40
when record(Val, 'MegacoMessage') ->
43
enc_AuthenticationHeader(Val#'MegacoMessage'.authHeader, State),
44
enc_Message(Val#'MegacoMessage'.mess, State)
47
%% Note that encoding the transaction this way
48
%% make the message look a bit strange.
49
enc_Transaction(Val) ->
51
enc_Transaction(Val, State).
53
%% Note that encoding the action request's this way
54
%% make the message look a bit strange.
55
enc_ActionRequests(Val) ->
57
enc_TransactionRequest_actions(Val, State).
59
%% Note that encoding the action request this way
60
%% make the message look a bit strange.
61
enc_ActionRequest(Val) ->
63
enc_ActionRequest(Val, State).
65
enc_CommandRequest(Val) ->
67
enc_CommandRequest(Val, State).
69
enc_ActionReply(Val) ->
71
enc_ActionReply(Val, State).
73
enc_AuthenticationHeader(asn1_NOVALUE, _State) ->
75
enc_AuthenticationHeader(Val, State)
76
when record(Val, 'AuthenticationHeader') ->
80
enc_SecurityParmIndex(Val#'AuthenticationHeader'.secParmIndex, State),
82
enc_SequenceNum(Val#'AuthenticationHeader'.seqNum, State),
84
enc_AuthData(Val#'AuthenticationHeader'.ad, State),
88
enc_SecurityParmIndex({'SecurityParmIndex',Val}, State) ->
89
enc_SecurityParmIndex(Val, State);
90
enc_SecurityParmIndex(Val, State) ->
93
enc_HEXDIG(Val, State, 8, 8)
96
enc_SequenceNum({'SequenceNum',Val}, State) ->
97
enc_SequenceNum(Val, State);
98
enc_SequenceNum(Val, State) ->
101
enc_HEXDIG(Val, State, 8, 8)
104
enc_AuthData({'AuthData',Val}, State) ->
105
enc_AuthData(Val, State);
106
enc_AuthData(Val, State) ->
109
enc_HEXDIG(Val, State, 24, 64) %% OTP-4710
112
enc_Message(Val, State)
113
when record(Val, 'Message') ->
117
enc_version(Val#'Message'.version, State),
119
enc_MId(Val#'Message'.mId, State),
121
enc_Message_messageBody(Val#'Message'.messageBody, State)
124
enc_version(Val, State) when integer(Val), Val >= 0 ->
125
enc_DIGIT(Val, State, 0, 99).
127
enc_Message_messageBody({'Message_messageBody',Val}, State) ->
128
enc_Message_messageBody(Val, State);
129
enc_Message_messageBody({Tag, Val}, State) ->
132
enc_ErrorDescriptor(Val, State);
134
enc_Message_messageBody_transactions(Val, State);
136
error({invalid_messageBody_tag, Tag})
139
enc_Message_messageBody_transactions({'Message_messageBody_transactions',Val},
141
enc_Message_messageBody_transactions(Val, State);
142
enc_Message_messageBody_transactions(Val, State)
143
when list(Val), Val /= []->
144
[enc_Transaction(T, State) || T <- Val].
146
enc_MId({'MId',Val}, State) ->
148
enc_MId({Tag, Val}, State) ->
151
enc_IP4Address(Val, State);
153
enc_IP6Address(Val, State);
155
enc_DomainName(Val, State);
157
enc_PathName(Val, State);
159
enc_mtpAddress(Val, State);
161
error({invalid_MId_tag, Tag})
164
enc_mtpAddress(Val, State) ->
168
enc_OCTET_STRING(Val, State, 2, 4),
172
enc_DomainName(Val, State)
173
when record(Val, 'DomainName') ->
176
%% BUGBUG: (ALPHA / DIGIT) *63(ALPHA / DIGIT / "-" / ".")
177
enc_STRING(Val#'DomainName'.name, State, 1, 64),
179
case Val#'DomainName'.portNumber of
185
enc_portNumber(PortNumber, State)
190
enc_IP4Address(Val, State)
191
when record(Val, 'IP4Address') ->
192
[A1, A2, A3, A4] = Val#'IP4Address'.address,
195
enc_V4hex(A1, State),
197
enc_V4hex(A2, State),
199
enc_V4hex(A3, State),
201
enc_V4hex(A4, State),
203
case Val#'IP4Address'.portNumber of
209
enc_portNumber(PortNumber, State)
214
enc_V4hex(Val, State) ->
215
enc_DIGIT(Val, State, 0, 255).
217
enc_IP6Address(Val, State)
218
when record(Val, 'IP6Address'),
219
list(Val#'IP6Address'.address),
220
length(Val#'IP6Address'.address) == 16 ->
223
enc_IP6Address_address(Val#'IP6Address'.address, State),
225
case Val#'IP6Address'.portNumber of
231
enc_portNumber(PortNumber, State)
236
enc_IP6Address_address([0, 0|Addr], State) ->
237
enc_IP6Address_address2(Addr, 1, false, true, State);
238
enc_IP6Address_address(Addr, State) ->
239
enc_IP6Address_address2(Addr, 0, false, false, State).
241
enc_IP6Address_address2([0,0], 0, _Padding, _First, _State) ->
243
enc_IP6Address_address2([0,0], PadN, false, true, _State) when PadN > 0 ->
244
[$:, $:]; % Padding from the beginning (all zero's)
245
enc_IP6Address_address2([0,0], PadN, false, false, _State) when PadN > 0 ->
246
[$:]; % Padding in the middle or end
247
enc_IP6Address_address2([0,0], _, true, _First, _State) ->
249
enc_IP6Address_address2([N1,N2], 0, _Padding, _First, State) ->
250
[enc_hex4([N1, N2], State)];
251
enc_IP6Address_address2([N1,N2], 1, _Padding, _First, State) ->
252
[$0, $:, enc_hex4([N1, N2], State)];
253
enc_IP6Address_address2([N1,N2], PadN, false, true, State) when PadN > 1 ->
254
[$:, $:, enc_hex4([N1, N2], State)];
255
enc_IP6Address_address2([N1,N2], PadN, false, false, State) when PadN > 1 ->
256
[$:, enc_hex4([N1, N2], State)];
257
enc_IP6Address_address2([N1,N2], _PadN, true, _First, State) ->
258
[enc_hex4([N1, N2], State)];
259
enc_IP6Address_address2([0, 0|Ns], PadN, false, First, State) ->
260
enc_IP6Address_address2(Ns, PadN+1, false, First, State);
261
enc_IP6Address_address2([0, 0|Ns], _PadN, true, _First, State) ->
265
enc_IP6Address_address2(Ns, 0, true, false, State)
267
enc_IP6Address_address2([N1, N2|Ns], 0, Padded, _First, State) ->
269
enc_hex4([N1, N2], State),
271
enc_IP6Address_address2(Ns, 0, Padded, false, State)
273
enc_IP6Address_address2([N1, N2|Ns], 1, Padded, _First, State) ->
277
enc_hex4([N1, N2], State),
279
enc_IP6Address_address2(Ns, 0, Padded, false, State)
281
enc_IP6Address_address2([N1, N2|Ns], PadN, false, true, State) when PadN > 1 ->
282
%% Padding from the beginning
286
enc_hex4([N1, N2], State),
288
enc_IP6Address_address2(Ns, 0, true, false, State)
290
enc_IP6Address_address2([N1, N2|Ns], PadN, false, false, State)
293
$:, %% The other ':' has already added
294
enc_hex4([N1, N2], State),
296
enc_IP6Address_address2(Ns, 0, true, false, State)
298
enc_IP6Address_address2([N1, N2|Ns], _PadN, true, _First, State) ->
300
enc_hex4([N1, N2], State),
302
enc_IP6Address_address2(Ns, 0, true, false, State)
306
enc_hex4([0,0], _State) ->
308
enc_hex4([0,N], _State) ->
310
enc_hex4([N1, N2], _State) when N2 =< 15 ->
311
[hex(N1), $0, hex(N2)];
312
enc_hex4([N1, N2], _State) ->
315
enc_PathName({'PathName',Val}, State) ->
316
enc_PathName(Val, State);
317
enc_PathName(Val, State) ->
318
%% BUGBUG: ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" )
319
%% BUGBUG: ["@" pathDomainName ]
320
enc_STRING(Val, State, 1, 64).
322
enc_Transaction(Bin, _State) when binary(Bin) ->
323
[Bin]; %% Already encoded...
324
enc_Transaction({'Transaction',Val}, State) ->
325
enc_Transaction(Val, State);
326
enc_Transaction({Tag, Val}, State) ->
328
transactionRequest ->
329
enc_TransactionRequest(Val, State);
330
transactionPending ->
331
enc_TransactionPending(Val, State);
333
enc_TransactionReply(Val, State);
334
transactionResponseAck ->
335
enc_TransactionResponseAck(Val, State);
337
error({invalid_Transaction_tag, Tag})
340
enc_TransactionResponseAck([Mand | Opt], State) ->
343
?LBRKT_INDENT(State),
344
[enc_TransactionAck(Mand, State) |
345
[[?COMMA_INDENT(State), enc_TransactionAck(Val, State)] || Val <- Opt]],
349
enc_TransactionAck(Val, State)
350
when record(Val, 'TransactionAck') ->
352
enc_TransactionId(Val#'TransactionAck'.firstAck, ?INC_INDENT(State)),
353
case Val#'TransactionAck'.lastAck of
357
["-",enc_TransactionId(LastAck, State)]
361
enc_TransactionId({'TransactionId',Val}, State) ->
362
enc_TransactionId(Val, State);
363
enc_TransactionId(Val, State) ->
364
enc_UINT32(Val, State).
366
enc_TransactionRequest(#'TransactionRequest'{transactionId = Tid,
367
actions = Acts}, State) ->
371
enc_TransactionId(Tid, State),
372
?LBRKT_INDENT(State),
373
enc_TransactionRequest_actions(Acts, ?INC_INDENT(State)),
376
enc_TransactionRequest(Bin, _State) when binary(Bin) ->
379
enc_TransactionRequest_actions(Bin, _State) when binary(Bin) ->
380
[Bin]; %% Already encoded...
381
enc_TransactionRequest_actions({'TransactionRequest_actions',Val}, State) ->
382
enc_TransactionRequest_actions(Val, State);
383
enc_TransactionRequest_actions([Mand | Opt], State) ->
384
[enc_ActionRequest(Mand, State) |
385
[[?COMMA_INDENT(State), enc_ActionRequest(Val, State)] || Val <- Opt]].
387
enc_TransactionPending(#'TransactionPending'{transactionId = Tid}, State) ->
390
enc_TransactionId(Tid, State),
391
?LBRKT_INDENT(State),
394
enc_TransactionPending(Bin, _State) when binary(Bin) ->
397
enc_TransactionReply(#'TransactionReply'{transactionId = Tid,
398
immAckRequired = Req,
399
transactionResult = Res}, State) ->
403
enc_TransactionId(Tid, State),
404
?LBRKT_INDENT(State),
405
enc_immAckRequired(Req, State),
406
enc_TransactionReply_transactionResult(Res, ?INC_INDENT(State)),
409
enc_TransactionReply(Bin, _State) when binary(Bin) ->
412
enc_immAckRequired(Val, State) ->
417
[?ImmAckRequiredToken, ?COMMA_INDENT(?INC_INDENT(State))]
420
enc_TransactionReply_transactionResult({'TransactionReply_transactionResult',
422
enc_TransactionReply_transactionResult(Val, State);
423
enc_TransactionReply_transactionResult({Tag, Val}, State) ->
426
enc_ErrorDescriptor(Val, State);
428
enc_TransactionReply_transactionResult_actionReplies(Val, State);
430
error({invalid_TransactionReply_transactionResult_tag, Tag})
433
enc_TransactionReply_transactionResult_actionReplies({'TransactionReply_transactionResult_actionReplies',Val}, State) ->
434
enc_TransactionReply_transactionResult_actionReplies(Val, State);
435
enc_TransactionReply_transactionResult_actionReplies([Mand | Opt], State) ->
436
[enc_ActionReply(Mand, State),
437
[[?COMMA_INDENT(State), enc_ActionReply(Val, State)] || Val <- Opt]].
439
enc_ErrorDescriptor(Val, State)
440
when record(Val, 'ErrorDescriptor') ->
444
enc_ErrorCode(Val#'ErrorDescriptor'.errorCode, State),
446
case Val#'ErrorDescriptor'.errorText of
450
enc_ErrorText(ErrorText, State)
455
enc_ErrorCode({'ErrorCode',Val}, State)->
456
enc_ErrorCode(Val, State);
457
enc_ErrorCode(Val, State) ->
458
enc_DIGIT(Val, State, 0, 999).
460
enc_ErrorText({'ErrorText',Val}, State) ->
461
enc_ErrorText(Val, State);
462
enc_ErrorText(Val, State) ->
463
enc_QUOTED_STRING(Val, State).
465
enc_ContextID({'ContextID',Val}, State) ->
466
enc_ContextID(Val, State);
467
enc_ContextID(Val, State) ->
469
?megaco_all_context_id -> $*;
470
?megaco_null_context_id -> $-;
471
?megaco_choose_context_id -> $$;
472
Int when integer(Int) -> enc_UINT32(Int, State)
475
enc_ActionRequest(Bin, _State) when binary(Bin) ->
476
[Bin]; %% Already encoded...
477
enc_ActionRequest(Val, State)
478
when record(Val, 'ActionRequest') ->
482
enc_ContextID(Val#'ActionRequest'.contextId, State),
483
?LBRKT_INDENT(State),
484
enc_list([{[Val#'ActionRequest'.contextRequest],
485
fun enc_ContextRequest/2},
486
{[Val#'ActionRequest'.contextAttrAuditReq],
487
fun enc_ContextAttrAuditRequest/2},
488
{Val#'ActionRequest'.commandRequests,
489
fun enc_CommandRequest/2}],
495
enc_ActionReply(#'ActionReply'{contextId = Id,
496
errorDescriptor = ED,
497
contextReply = CtxRep,
498
commandReply = CmdRep},
500
% d("enc_ActionReply -> entry with"
504
% "~n CmdRep: ~p", [Id, ED, CtxRep, CmdRep]),
508
enc_ContextID(Id, State),
509
?LBRKT_INDENT(State),
510
do_enc_ActionReply(ED, CtxRep, CmdRep, State),
514
do_enc_ActionReply(asn1_NOVALUE, CtxRep, [], State)
515
when CtxRep =/= asn1_NOVALUE ->
516
% d("do_enc_ActionReply -> entry with"
517
% "~n CtxRep: ~p", [CtxRep]),
519
enc_ContextRequest(CtxRep, ?INC_INDENT(State))
521
do_enc_ActionReply(asn1_NOVALUE, CtxRep, CmdRep, State)
522
when CtxRep =/= asn1_NOVALUE, CmdRep =/= [] ->
523
% d("do_enc_ActionReply -> entry with"
525
% "~n CmdRep: ~p", [CtxRep, CmdRep]),
527
enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
528
?COMMA_INDENT(?INC_INDENT(State)),
529
enc_list([{CmdRep, fun enc_CommandReply/2}],
532
do_enc_ActionReply(asn1_NOVALUE, asn1_NOVALUE, CmdRep, State)
533
when CmdRep =/= [] ->
534
% d("do_enc_ActionReply -> entry with"
535
% "~n CmdRep: ~p", [CmdRep]),
537
enc_list([{CmdRep, fun enc_CommandReply/2}],
540
do_enc_ActionReply(ED, CtxRep, [], State)
541
when ED =/= asn1_NOVALUE, CtxRep =/= asn1_NOVALUE ->
542
% d("do_enc_ActionReply -> entry with"
544
% "~n CtxRep: ~p", [ED, CtxRep]),
546
enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
547
?COMMA_INDENT(?INC_INDENT(State)),
548
enc_list([{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
551
do_enc_ActionReply(ED, asn1_NOVALUE, CmdRep, State)
552
when ED =/= asn1_NOVALUE, CmdRep =/= [] ->
553
% d("do_enc_ActionReply -> entry with"
555
% "~n CmdRep: ~p", [ED, CmdRep]),
557
enc_list([{CmdRep, fun enc_CommandReply/2},
558
{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
561
do_enc_ActionReply(ED, CtxRep, CmdRep, State)
562
when ED =/= asn1_NOVALUE, CtxRep =/= asn1_NOVALUE, CmdRep =/= [] ->
563
% d("do_enc_ActionReply -> entry with"
566
% "~n CmdRep: ~p", [ED, CtxRep, CmdRep]),
568
enc_ContextRequest(CtxRep, ?INC_INDENT(State)),
569
?COMMA_INDENT(?INC_INDENT(State)),
570
enc_list([{CmdRep, fun enc_CommandReply/2},
571
{[ED], fun enc_ErrorDescriptor/2}], % Indention cosmetics
574
do_enc_ActionReply(ED, asn1_NOVALUE, [], State)
575
when ED =/= asn1_NOVALUE ->
576
% d("do_enc_ActionReply -> entry with"
577
% "~n ED: ~p", [ED]),
579
enc_ErrorDescriptor(ED, ?INC_INDENT(State))
583
enc_ContextRequest_priority(asn1_NOVALUE, _State) ->
585
enc_ContextRequest_priority(Val, _State) ->
586
{[Val], fun(X,S) -> [?PriorityToken,?EQUAL,enc_UINT16(X, S)] end}.
588
enc_ContextRequest_emergency(asn1_NOVALUE, _State) ->
590
enc_ContextRequest_emergency(true, _State) ->
591
{[?EmergencyToken], fun(Elem, _) -> Elem end};
592
enc_ContextRequest_emergency(false, _State) ->
593
{[?EmergencyOffToken], fun(Elem, _) -> Elem end}.
595
enc_ContextRequest_topologyReq(asn1_NOVALUE, _State) ->
597
enc_ContextRequest_topologyReq({'ContextRequest_topologyReq',
598
asn1_NOVALUE}, _State) ->
600
enc_ContextRequest_topologyReq({'ContextRequest_topologyReq',
602
{List, fun enc_TopologyRequest/2};
603
enc_ContextRequest_topologyReq(List, _State) ->
604
{[List], fun enc_TopologyRequest/2}.
606
enc_ContextRequest_iepsCallind(asn1_NOVALUE, _State) ->
608
enc_ContextRequest_iepsCallind(false, _State) ->
610
% enc_ContextRequest_iepsCallind(false, _State) ->
611
% {[?IEPS_XXXX_Token], fun(Elem, _) -> Elem end};
612
enc_ContextRequest_iepsCallind(true, _State) ->
613
{[?IEPSToken], fun(Elem, _) -> Elem end}.
615
enc_ContextRequest_contextProp(asn1_NOVALUE, _State) ->
617
enc_ContextRequest_contextProp([], _State) ->
619
enc_ContextRequest_contextProp([PP], _State) ->
620
{[PP], fun enc_PropertyParm/2};
621
enc_ContextRequest_contextProp(PPs, _State) when list(PPs) ->
622
error({at_most_one_contextProp, PPs}).
624
enc_ContextRequest(asn1_NOVALUE, _State) ->
626
enc_ContextRequest(#'ContextRequest'{priority = asn1_NOVALUE,
627
emergency = asn1_NOVALUE,
628
topologyReq = asn1_NOVALUE,
629
iepsCallind = asn1_NOVALUE,
630
contextProp = asn1_NOVALUE}, _State) ->
632
enc_ContextRequest(#'ContextRequest'{priority = asn1_NOVALUE,
633
emergency = asn1_NOVALUE,
635
iepsCallind = asn1_NOVALUE,
636
contextProp = []}, _State) ->
638
enc_ContextRequest(#'ContextRequest'{priority = Prio,
642
contextProp = CP}, State) ->
645
?LBRKT_INDENT(State),
646
enc_list([enc_ContextRequest_priority(Prio, State),
647
enc_ContextRequest_emergency(Em, State),
648
enc_ContextRequest_topologyReq(TR, State),
649
enc_ContextRequest_iepsCallind(Ieps, State),
650
enc_ContextRequest_contextProp(CP, State)],
655
enc_ContextAttrAuditRequest(
656
#'ContextAttrAuditRequest'{topology = asn1_NOVALUE,
657
emergency = asn1_NOVALUE,
658
priority = asn1_NOVALUE,
659
iepsCallind = asn1_NOVALUE,
660
contextPropAud = asn1_NOVALUE}, _State) ->
662
enc_ContextAttrAuditRequest(
663
#'ContextAttrAuditRequest'{topology = asn1_NOVALUE,
664
emergency = asn1_NOVALUE,
665
priority = asn1_NOVALUE,
666
iepsCallind = asn1_NOVALUE,
667
contextPropAud = []}, _State) ->
669
enc_ContextAttrAuditRequest(CAAR, State) ->
672
?LBRKT_INDENT(State),
673
enc_IndAudContextAttrDescriptor(CAAR, ?INC_INDENT(State)),
677
enc_IndAudContextAttrDescriptor(
678
#'ContextAttrAuditRequest'{topology = Top,
682
contextPropAud = CPA}, State) ->
685
?LBRKT_INDENT(State),
686
enc_list([{[Top], fun('NULL', _) -> ?TopologyToken end},
687
{[Em], fun('NULL', _) -> ?EmergencyToken end},
688
{[Prio], fun('NULL', _) -> ?PriorityToken end},
689
{[Ieps], fun('NULL', _) -> ?IEPSToken end},
690
{CPA, fun enc_IndAudPropertyParm/2}],
695
enc_CommandRequest(Val, State)
696
when record(Val, 'CommandRequest') ->
697
% d("enc_CommandRequest -> entry with"
698
% "~n Val: ~p", [Val]),
700
case Val#'CommandRequest'.optional of
706
case Val#'CommandRequest'.wildcardReturn of
712
enc_Command(Val#'CommandRequest'.command, State)
715
enc_Command({'Command',Val}, State) ->
716
enc_Command(Val, State);
717
enc_Command({Tag, Val}, State) ->
718
% d("enc_Command -> entry with"
720
% "~n Val: ~p", [Tag, Val]),
723
[?AddToken, enc_AmmRequest(Val, State)];
725
[?MoveToken, enc_AmmRequest(Val, State)];
727
[?ModifyToken, enc_AmmRequest(Val, State)];
729
[?SubtractToken, enc_SubtractRequest(Val, State)];
731
[?AuditCapToken, enc_AuditRequest(Val, State)];
733
[?AuditValueToken, enc_AuditRequest(Val, State)];
735
[?NotifyToken, enc_NotifyRequest(Val, State)];
737
[?ServiceChangeToken, enc_ServiceChangeRequest(Val, State)];
739
error({invalid_Command_tag, Tag})
742
enc_CommandReply({'CommandReply',Val}, State) ->
743
enc_CommandReply(Val, State);
744
enc_CommandReply({Tag, Val}, State) ->
745
% d("enc_CommandReply -> entry with"
747
% "~n Val: ~p", [Tag, Val]),
750
[?AddToken, enc_AmmsReply(Val, State)];
752
[?MoveToken, enc_AmmsReply(Val, State)];
754
[?ModifyToken, enc_AmmsReply(Val, State)];
756
[?SubtractToken, enc_AmmsReply(Val, State)];
758
[?AuditCapToken, enc_AuditReply(Val, State)];
760
[?AuditValueToken, enc_AuditReply(Val, State)];
762
[?NotifyToken, enc_NotifyReply(Val, State)];
763
serviceChangeReply ->
764
[?ServiceChangeToken, enc_ServiceChangeReply(Val, State)];
766
error({invalid_CommandReply_tag, Tag})
769
enc_TopologyRequest(Val, State)
773
?LBRKT_INDENT(State),
774
enc_list([{Val, fun enc_TopologyRequest1/2}],?INC_INDENT(State)),
778
enc_TopologyRequest1(#'TopologyRequest'{terminationFrom = From,
780
topologyDirection = Dir}, State) ->
782
enc_TerminationID(From, State),
783
?COMMA_INDENT(State),
784
enc_TerminationID(To, State),
785
?COMMA_INDENT(State),
786
enc_TopologyDirection(Dir, State)
789
enc_TopologyDirection(bothway, _State) ->
791
enc_TopologyDirection(isolate, _State) ->
793
enc_TopologyDirection(oneway, _State) ->
795
enc_TopologyDirection(Top, _State) ->
796
error({illegal_TopologyDirection, Top}).
798
enc_AmmRequest(Val, State)
799
when record(Val, 'AmmRequest') ->
800
% d("enc_AmmRequest -> entry with"
801
% "~n Val: ~p", [Val]),
803
%% Assume that Token is added elsewhere
805
enc_TerminationIDList1(Val#'AmmRequest'.terminationID, State),
807
enc_list([{Val#'AmmRequest'.descriptors, fun enc_ammDescriptor/2}],
812
enc_ammDescriptor({Tag, Desc}, State) ->
813
% d("enc_ammDescriptor -> entry with"
815
% "~n Desc: ~p", [Tag, Desc]),
817
mediaDescriptor -> enc_MediaDescriptor(Desc, State);
818
modemDescriptor -> enc_ModemDescriptor(Desc, State);
819
muxDescriptor -> enc_MuxDescriptor(Desc, State);
820
eventsDescriptor -> enc_EventsDescriptor(Desc, State);
821
eventBufferDescriptor -> enc_EventBufferDescriptor(Desc, State);
822
signalsDescriptor -> enc_SignalsDescriptor(Desc, State);
823
digitMapDescriptor -> enc_DigitMapDescriptor(Desc, State);
824
auditDescriptor -> enc_AuditDescriptor(Desc, State);
825
statisticsDescriptor -> enc_StatisticsDescriptor(Desc, State);
827
error({invalid_ammDescriptor_tag, Tag})
830
enc_AmmsReply(#'AmmsReply'{terminationID = ID,
831
terminationAudit = asn1_NOVALUE}, State) ->
832
% d("enc_AmmsReply(asn1_NOVALUE) -> entry with"
833
% "~n ID: ~p", [ID]),
836
enc_TerminationIDList1(ID, State)
838
enc_AmmsReply(#'AmmsReply'{terminationID = ID,
839
terminationAudit = []}, State) ->
840
% d("enc_AmmsReply([]) -> entry with"
841
% "~n ID: ~p", [ID]),
844
enc_TerminationIDList1(ID, State)
846
enc_AmmsReply(#'AmmsReply'{terminationID = ID,
847
terminationAudit = Res}, State) ->
848
% d("enc_AmmsReply -> entry with"
850
% "~n Res: ~p", [ID, Res]),
853
enc_TerminationIDList1(ID, State),
854
case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
859
?LBRKT_INDENT(State),
866
enc_SubtractRequest(Val, State)
867
when record(Val, 'SubtractRequest') ->
869
%% Assume that Token is added elsewhere
871
enc_TerminationIDList1(Val#'SubtractRequest'.terminationID, State),
872
case Val#'SubtractRequest'.auditDescriptor of
877
?LBRKT_INDENT(State) ,
878
enc_AuditDescriptor(AuditDescr, ?INC_INDENT(State)),
884
enc_AuditRequest(Val, State)
885
when record(Val, 'AuditRequest') ->
886
% d("enc_AuditRequest -> entry with"
887
% "~n Val: ~p", [Val]),
889
%% Assume that Token is added elsewhere
891
enc_TerminationIDList1([Val#'AuditRequest'.terminationID], State),
892
case Val#'AuditRequest'.auditDescriptor of
897
?LBRKT_INDENT(State) ,
898
enc_AuditDescriptor(AuditDescr, ?INC_INDENT(State)),
904
%% auditReply = (AuditValueToken / AuditCapToken )
905
%% ( contextTerminationAudit / auditOther)
906
%% auditOther = EQUAL TerminationID LBRKT
907
%% terminationAudit RBRKT
908
%% terminationAudit = auditReturnParameter *(COMMA auditReturnParameter)
910
%% contextTerminationAudit = EQUAL CtxToken ( terminationIDList /
911
%% LBRKT errorDescriptor RBRKT )
912
enc_AuditReply({Tag, Val}, State) ->
914
contextAuditResult ->
918
enc_TerminationIDListN(Val, State)
924
?LBRKT_INDENT(State),
925
enc_ErrorDescriptor(Val, ?INC_INDENT(State)),
928
auditResult when record(Val, 'AuditResult') ->
929
enc_auditOther(Val, State);
931
error({invalid_auditResult, Val});
933
error({invalid_AuditReply_tag, Tag})
936
enc_auditOther(#'AuditResult'{terminationID = ID,
937
terminationAuditResult = asn1_NOVALUE}, State) ->
940
enc_TerminationID(ID, State)
942
enc_auditOther(#'AuditResult'{terminationID = ID,
943
terminationAuditResult = []}, State) ->
946
enc_TerminationID(ID, State)
948
enc_auditOther(#'AuditResult'{terminationID = ID,
949
terminationAuditResult = Res}, State) ->
952
enc_TerminationID(ID, State),
953
case lists:flatten(enc_TerminationAudit(Res, ?INC_INDENT(State))) of
958
?LBRKT_INDENT(State),
966
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = asn1_NOVALUE,
967
auditPropertyToken = asn1_NOVALUE},
969
% d("enc_AuditDescriptor(asn1_NOVALUE) -> entry"),
974
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = [],
975
auditPropertyToken = asn1_NOVALUE},
977
% d("enc_AuditDescriptor([]) -> entry"),
982
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
983
auditPropertyToken = asn1_NOVALUE},
985
% d("enc_AuditDescriptor -> entry with",
986
% "~n List: ~p", [List]),
990
?LBRKT_INDENT(State),
991
enc_list([{List, fun enc_auditItem/2}], ?INC_INDENT(State)),
996
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = asn1_NOVALUE,
997
auditPropertyToken = Prop},
999
% d("enc_AuditDescriptor -> entry with",
1000
% "~n Prop: ~p", [Prop]),
1004
?LBRKT_INDENT(State),
1005
enc_auditPropertyToken(Prop, ?INC_INDENT(State)),
1006
?RBRKT_INDENT(State)
1009
enc_AuditDescriptor(#'AuditDescriptor'{auditToken = List,
1010
auditPropertyToken = Prop},
1012
% d("enc_AuditDescriptor -> entry with",
1014
% "~n Prop: ~p", [List, Prop]),
1018
?LBRKT_INDENT(State),
1019
enc_list([{List, fun enc_auditItem/2}], ?INC_INDENT(State)),
1020
?COMMA_INDENT(State),
1021
enc_auditPropertyToken(Prop, ?INC_INDENT(State)), % v2
1022
?RBRKT_INDENT(State)
1026
enc_auditItem(signalsToken, _State) ->
1028
enc_auditItem(eventBufferToken, _State) ->
1030
enc_auditItem(eventsToken, _State) ->
1032
enc_auditItem(Val, State) ->
1033
enc_auditReturnItem(Val, State).
1036
enc_auditReturnItem(muxToken, _State) ->
1038
enc_auditReturnItem(modemToken, _State) ->
1040
enc_auditReturnItem(mediaToken, _State) ->
1042
enc_auditReturnItem(digitMapToken, _State) ->
1044
enc_auditReturnItem(statsToken, _State) ->
1046
enc_auditReturnItem(observedEventsToken, _State) ->
1047
?ObservedEventsToken;
1048
enc_auditReturnItem(packagesToken, _State) ->
1054
enc_auditPropertyToken([], _State) ->
1056
enc_auditPropertyToken([Param | Params], State) ->
1057
% d("enc_auditPropertyToken -> entry with",
1058
% "~n Param: ~p", [Param]),
1059
[enc_IndAudauditReturnParameter(Param, State),
1060
[[?COMMA_INDENT(State),
1061
enc_IndAudauditReturnParameter(P, State)] || P <- Params]].
1064
enc_IndAudauditReturnParameter({Tag, Val}, State) ->
1066
indAudMediaDescriptor ->
1067
enc_IndAudMediaDescriptor(Val, State);
1068
indAudEventsDescriptor ->
1069
enc_IndAudEventsDescriptor(Val, State);
1070
indAudSignalsDescriptor ->
1071
enc_IndAudSignalsDescriptor(Val, State);
1072
indAudDigitMapDescriptor ->
1073
enc_IndAudDigitMapDescriptor(Val, State);
1074
indAudEventBufferDescriptor ->
1075
enc_IndAudEventBufferDescriptor(Val, State);
1076
indAudStatisticsDescriptor ->
1077
enc_IndAudStatisticsDescriptor(Val, State);
1078
indAudPackagesDescriptor ->
1079
enc_IndAudPackagesDescriptor(Val, State);
1081
error({invalid_IndAudauditReturnParameter_tag, Tag})
1084
%% The ASN.1 does not limit to just one of termStateDescr or streams,
1085
%% but the ABNF seams to do that...
1086
enc_IndAudMediaDescriptor(
1087
#'IndAudMediaDescriptor'{termStateDescr = asn1_NOVALUE,
1088
streams = Streams}, State) ->
1089
% d("enc_IndAudMediaDescriptor -> entry with",
1090
% "~n Streams: ~p", [Streams]),
1093
?LBRKT_INDENT(State),
1094
enc_IndAudMediaDescriptor_streams(Streams, ?INC_INDENT(State)),
1095
?RBRKT_INDENT(State)
1097
enc_IndAudMediaDescriptor(#'IndAudMediaDescriptor'{termStateDescr = TSD,
1098
streams = asn1_NOVALUE},
1100
% d("enc_IndAudMediaDescriptor -> entry with",
1101
% "~n TSD: ~p", [TSD]),
1104
?LBRKT_INDENT(State),
1105
enc_IndAudTerminationStateDescriptor(TSD, ?INC_INDENT(State)),
1106
?RBRKT_INDENT(State)
1109
enc_IndAudMediaDescriptor_streams({Tag, Val}, State) ->
1110
% d("enc_IndAudMediaDescriptor_streams -> entry with",
1112
% "~n Val: ~p", [Tag, Val]),
1115
enc_IndAudStreamParms(Val, State);
1117
enc_IndAudMediaDescriptor_multiStream(Val, State);
1119
error({invalid_IndAudMediaDescriptor_streams_tag, Tag})
1122
enc_IndAudTerminationStateDescriptor(
1123
#'IndAudTerminationStateDescriptor'{propertyParms = [],
1124
eventBufferControl = asn1_NOVALUE,
1125
serviceState = 'NULL'}, State) ->
1127
?TerminationStateToken,
1128
?LBRKT_INDENT(State),
1129
?ServiceStatesToken,
1130
?RBRKT_INDENT(State)
1132
enc_IndAudTerminationStateDescriptor(
1133
#'IndAudTerminationStateDescriptor'{propertyParms = [],
1134
eventBufferControl = 'NULL',
1135
serviceState = asn1_NOVALUE}, State) ->
1137
?TerminationStateToken,
1138
?LBRKT_INDENT(State),
1140
?RBRKT_INDENT(State)
1142
enc_IndAudTerminationStateDescriptor(
1143
#'IndAudTerminationStateDescriptor'{propertyParms = [Parms],
1144
eventBufferControl = asn1_NOVALUE,
1145
serviceState = asn1_NOVALUE}, State) ->
1146
#'IndAudPropertyParm'{name = Name} = Parms,
1148
?TerminationStateToken,
1149
?LBRKT_INDENT(State),
1150
enc_PkgdName(Name, State),
1151
?RBRKT_INDENT(State)
1154
%% In text, localDescriptor and remoteDescriptor are not allowed!!
1155
enc_IndAudStreamParms(
1156
#'IndAudStreamParms'{localControlDescriptor = LCD,
1157
localDescriptor = asn1_NOVALUE,
1158
remoteDescriptor = asn1_NOVALUE,
1159
statisticsDescriptor = SD}, State) ->
1160
% d("enc_IndAudStreamParms -> entry with"
1162
% "~n SD: ~p", [LCD, SD]),
1164
enc_list([{[LCD], fun enc_IndAudLocalControlDescriptor/2},
1165
{[SD], fun enc_IndAudStatisticsDescriptor/2}],
1169
enc_IndAudLocalControlDescriptor(Val, State)
1170
when record(Val, 'IndAudLocalControlDescriptor') ->
1173
?LBRKT_INDENT(State),
1174
enc_list([{[Val#'IndAudLocalControlDescriptor'.streamMode],
1175
fun('NULL', _) -> ?ModeToken end},
1176
{[Val#'IndAudLocalControlDescriptor'.reserveValue],
1177
fun('NULL', _) -> ?ReservedValueToken end},
1178
{[Val#'IndAudLocalControlDescriptor'.reserveGroup],
1179
fun('NULL', _) -> ?ReservedGroupToken end},
1180
{Val#'IndAudLocalControlDescriptor'.propertyParms,
1181
fun enc_IndAudPropertyParm/2}],
1182
?INC_INDENT(State)),
1183
?RBRKT_INDENT(State)
1186
enc_IndAudPropertyParm(#'IndAudPropertyParm'{name = PkgdName}, State) ->
1187
enc_PkgdName(PkgdName, State).
1189
enc_IndAudMediaDescriptor_multiStream([Val], State) ->
1190
% d("enc_IndAudMediaDescriptor_multiStream -> entry with"
1191
% "~n Val: ~p", [Val]),
1193
enc_IndAudStreamDescriptor(Val, ?INC_INDENT(State))
1195
enc_IndAudMediaDescriptor_multiStream(Vals, _State) when list(Vals) ->
1196
error({invalid_IndAudMediaDescriptor_multiStream_length, Vals});
1197
enc_IndAudMediaDescriptor_multiStream(Val, _State) ->
1198
error({invalid_IndAudMediaDescriptor_multiStream, Val}).
1200
enc_IndAudStreamDescriptor(#'IndAudStreamDescriptor'{streamID = SID,
1201
streamParms = Parms},
1203
% d("enc_IndAudStreamDescriptor -> entry with"
1205
% "~n Parms: ~p", [SID, Parms]),
1209
enc_StreamID(SID, State),
1210
?LBRKT_INDENT(State),
1211
enc_IndAudStreamParms(Parms, ?INC_INDENT(State)),
1212
?RBRKT_INDENT(State)
1215
enc_IndAudEventBufferDescriptor(Val, State)
1216
when record(Val, 'IndAudEventBufferDescriptor') ->
1217
#'IndAudEventBufferDescriptor'{eventName = EvName,
1218
streamID = ID} = Val,
1221
?LBRKT_INDENT(State),
1222
enc_PkgdName(EvName, State),
1223
enc_IndAudEventBufferDescriptor_eventSpec(ID, ?INC_INDENT(State)),
1224
?RBRKT_INDENT(State)
1227
enc_IndAudEventBufferDescriptor_eventSpec(asn1_NOVALUE, _State) ->
1230
enc_IndAudEventBufferDescriptor_eventSpec({eventParameterName, ParamName},
1233
?LBRKT_INDENT(State),
1234
enc_Name(ParamName, State),
1235
?RBRKT_INDENT(State)
1237
enc_IndAudEventBufferDescriptor_eventSpec(ID, State) ->
1239
?LBRKT_INDENT(State),
1240
enc_eventStream(ID, ?INC_INDENT(State)),
1241
?RBRKT_INDENT(State)
1244
enc_IndAudEventsDescriptor(Val, State)
1245
when record(Val, 'IndAudEventsDescriptor') ->
1246
#'IndAudEventsDescriptor'{requestID = ReqID,
1248
streamID = asn1_NOVALUE} = Val,
1252
enc_RequestID(ReqID, State),
1253
?LBRKT_INDENT(State),
1254
enc_PkgdName(Name, State),
1255
?RBRKT_INDENT(State)
1259
enc_IndAudSignalsDescriptor(Val, State) ->
1262
?LBRKT_INDENT(State),
1263
enc_IndAudSignalsDescriptor_value(Val, ?INC_INDENT(State)),
1264
?RBRKT_INDENT(State)
1267
enc_IndAudSignalsDescriptor_value({signal, Val}, State) ->
1268
enc_IndAudSignal(Val, State);
1269
enc_IndAudSignalsDescriptor_value({seqSigList, Val}, State) ->
1270
enc_IndAudSeqSigList(Val, State).
1272
enc_IndAudSignal(#'IndAudSignal'{signalName = SignalName,
1273
streamID = asn1_NOVALUE}, State) ->
1275
enc_SignalName(SignalName, State)
1278
enc_IndAudSeqSigList(#'IndAudSeqSigList'{id = ID,
1284
enc_UINT16(ID, State),
1285
?LBRKT_INDENT(State),
1286
enc_IndAudSignal(Parm, ?INC_INDENT(State)),
1287
?RBRKT_INDENT(State)
1290
enc_IndAudDigitMapDescriptor(#'IndAudDigitMapDescriptor'{digitMapName = Name},
1295
enc_DigitMapName(Name, State)
1298
enc_IndAudStatisticsDescriptor(#'IndAudStatisticsDescriptor'{statName = Name},
1300
% d("enc_IndAudStatisticsDescriptor -> entry with"
1301
% "~n Name: ~p", [Name]),
1304
?LBRKT_INDENT(State),
1305
enc_PkgdName(Name, State),
1306
?RBRKT_INDENT(State)
1310
enc_IndAudPackagesDescriptor(#'IndAudPackagesDescriptor'{packageName = N,
1311
packageVersion = V},
1315
?LBRKT_INDENT(State),
1318
enc_UINT16(V, State),
1319
?RBRKT_INDENT(State)
1326
enc_TerminationAudit({'TerminationAudit',Val}, State) ->
1327
enc_TerminationAudit(Val, State);
1328
enc_TerminationAudit([], _State) ->
1330
enc_TerminationAudit([Mand | Opt], State) ->
1331
% d("enc_TerminationAudit -> entry with"
1332
% "~n Mand: ~p", [Mand]),
1333
[enc_AuditReturnParameter(Mand, State),
1334
[[?COMMA_INDENT(State), enc_AuditReturnParameter(Val, State)] || Val <- Opt]].
1336
enc_AuditReturnParameter({'AuditReturnParameter',Val}, State) ->
1337
enc_AuditReturnParameter(Val, State);
1338
enc_AuditReturnParameter({Tag, Val}, State) ->
1339
% d("enc_AuditReturnParameter -> entry with"
1341
% "~n Val: ~p", [Tag, Val]),
1344
enc_MediaDescriptor(Val, State);
1346
enc_ModemDescriptor(Val, State);
1348
enc_MuxDescriptor(Val, State);
1350
enc_EventsDescriptor(Val, State);
1351
signalsDescriptor ->
1352
enc_SignalsDescriptor(Val, State);
1353
digitMapDescriptor ->
1354
enc_DigitMapDescriptor(Val, State);
1355
observedEventsDescriptor ->
1356
enc_ObservedEventsDescriptor(Val, State);
1357
eventBufferDescriptor ->
1358
enc_EventBufferDescriptor(Val, State);
1359
statisticsDescriptor ->
1360
enc_StatisticsDescriptor(Val, State);
1361
packagesDescriptor ->
1362
enc_PackagesDescriptor(Val, State);
1364
enc_ErrorDescriptor(Val, State);
1366
enc_EmptyDescriptors(Val, State);
1368
error({invalid_AuditReturnParameter_tag, Tag})
1371
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = asn1_NOVALUE}, _State) ->
1373
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = []}, _State) ->
1375
enc_EmptyDescriptors(#'AuditDescriptor'{auditToken = List}, State) ->
1376
enc_list([{List, fun enc_auditReturnItem/2}], ?INC_INDENT(State)).
1379
enc_NotifyRequest(Val, State)
1380
when record(Val, 'NotifyRequest') ->
1382
%% Assume that Token is added elsewhere
1384
enc_TerminationIDList1(Val#'NotifyRequest'.terminationID, State),
1385
?LBRKT_INDENT(State),
1386
%% BUGBUG: Mismatch between ASN.1 and ABNF
1387
%% BUGBUG: The following ought to be a 'choice'
1388
case Val#'NotifyRequest'.errorDescriptor of
1390
OED = Val#'NotifyRequest'.observedEventsDescriptor,
1391
enc_ObservedEventsDescriptor(OED, ?INC_INDENT(State));
1393
enc_ErrorDescriptor(ErrorDescr, ?INC_INDENT(State))
1395
?RBRKT_INDENT(State)
1398
enc_NotifyReply(Val, State)
1399
when record(Val, 'NotifyReply') ->
1401
%% Assume that Token is added elsewhere
1403
case Val#'NotifyReply'.terminationID of
1405
error(asn1_not_compliant_with_abnf);
1407
enc_TerminationIDList1(TermId, State)
1409
case Val#'NotifyReply'.errorDescriptor of
1414
?LBRKT_INDENT(State),
1415
enc_ErrorDescriptor(ErrorDescr, ?INC_INDENT(State)),
1416
?RBRKT_INDENT(State)
1421
enc_ObservedEventsDescriptor(Val, State)
1422
when record(Val, 'ObservedEventsDescriptor') ->
1424
?ObservedEventsToken,
1426
enc_RequestID(Val#'ObservedEventsDescriptor'.requestId, State),
1427
?LBRKT_INDENT(State),
1428
enc_observedEventsDescriptors(Val#'ObservedEventsDescriptor'.observedEventLst, ?INC_INDENT(State)),
1429
?RBRKT_INDENT(State)
1432
enc_observedEventsDescriptors([Mand | Opt], State) ->
1433
[enc_ObservedEvent(Mand, State),
1434
[[?COMMA_INDENT(State), enc_ObservedEvent(Val, State)] || Val <- Opt]].
1436
%% ;time per event, because it might be buffered
1437
%% observedEvent = [ TimeStamp LWSP COLON] LWSP
1438
%% pkgdName [ LBRKT observedEventParameter
1439
%% *(COMMA observedEventParameter) RBRKT ]
1441
%% ;at-most-once eventStream, every eventParameterName at most once
1442
%% observedEventParameter = eventStream / eventOther
1443
enc_ObservedEvent(Val, State)
1444
when record(Val, 'ObservedEvent') ->
1446
case Val#'ObservedEvent'.timeNotation of
1451
enc_TimeNotation(TimeStamp, State),
1457
enc_EventName(Val#'ObservedEvent'.eventName, State),
1459
enc_list([{[Val#'ObservedEvent'.streamID], fun enc_eventStream/2},
1460
{Val#'ObservedEvent'.eventParList, fun enc_eventOther/2}],
1461
?INC_INDENT(State)),
1465
enc_EventName({'EventName',Val}, State) ->
1466
enc_EventName(Val, State);
1467
enc_EventName(Val, State) ->
1468
PkgdName = ?META_ENC(event, Val),
1469
enc_PkgdName(PkgdName, State).
1471
enc_eventStream(Val, State) ->
1475
enc_StreamID(Val, State)
1478
enc_eventOther(#'EventParameter'{eventParameterName = Name,
1480
extraInfo = Extra}, State) ->
1482
enc_Name(Name, State),
1483
enc_propertyParmValues(Value, Extra, State)
1486
enc_ServiceChangeRequest(Val, State)
1487
when record(Val, 'ServiceChangeRequest') ->
1489
%% Assume that Token is added elsewhere
1491
enc_TerminationIDList1(Val#'ServiceChangeRequest'.terminationID, State),
1492
?LBRKT_INDENT(State),
1493
enc_ServiceChangeParm(Val#'ServiceChangeRequest'.serviceChangeParms,
1494
?INC_INDENT(State)),
1495
?RBRKT_INDENT(State)
1498
%% serviceChangeReply = ServiceChangeToken EQUAL TerminationID
1499
%% [LBRKT (errorDescriptor /
1500
%% serviceChangeReplyDescriptor) RBRKT]
1501
%% serviceChangeReplyDescriptor = ServicesToken LBRKT
1502
%% servChgReplyParm *(COMMA servChgReplyParm) RBRKT
1504
%% ;at-most-once. Version is REQUIRED on first ServiceChange response
1505
%% servChgReplyParm = (serviceChangeAddress / serviceChangeMgcId /
1506
%% serviceChangeProfile / serviceChangeVersion )
1507
enc_ServiceChangeReply(Val, State)
1508
when record(Val, 'ServiceChangeReply') ->
1510
%% Assume that Token is added elsewhere
1512
enc_TerminationIDList1(Val#'ServiceChangeReply'.terminationID, State),
1513
enc_ServiceChangeResult(Val#'ServiceChangeReply'.serviceChangeResult, State)
1516
enc_ServiceChangeResult({'ServiceChangeResult',Val}, State) ->
1517
enc_ServiceChangeResult(Val, State);
1518
enc_ServiceChangeResult({Tag, Val}, State) ->
1522
?LBRKT_INDENT(State),
1523
enc_ErrorDescriptor(Val, ?INC_INDENT(State)),
1524
?RBRKT_INDENT(State)
1526
serviceChangeResParms ->
1527
case enc_ServiceChangeResParm(Val, ?INC_INDENT(?INC_INDENT(State))) of
1532
?LBRKT_INDENT(State),
1540
end(?INC_INDENT(State)),
1541
?RBRKT_INDENT(State)
1545
error({invalid_ServiceChangeResult_tag, Tag})
1548
%% Required length of termination ID list is 1
1549
enc_TerminationIDList1({'TerminationIDList',Val}, State) ->
1550
enc_TerminationIDList1(Val, State);
1551
enc_TerminationIDList1([Singleton], State) ->
1552
enc_TerminationID(Singleton, State).
1554
%% No required length of termination ID list
1555
enc_TerminationIDListN({'TerminationIDList',Val}, State) ->
1556
enc_TerminationIDListN(Val, State);
1557
enc_TerminationIDListN(TidList, State) ->
1558
enc_list([{TidList, fun enc_TerminationID/2}], State).
1560
%% TerminationID = "ROOT" / pathNAME / "$" / "*"
1561
%% ; Total length of pathNAME must not exceed 64 chars.
1562
%% pathNAME = ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" )
1563
%% ["@" pathDomainName ]
1564
enc_TerminationID(Tid, State)
1565
when record(Tid, megaco_term_id) ->
1566
List = [{Tid#megaco_term_id.id, fun enc_tid_component/2 }],
1567
enc_list(List, State, fun(_S) -> ?SLASH end, false).
1569
enc_tid_component(Component, State) when list(Component) ->
1570
[enc_tid_sub_component(Sub, State) || Sub <- Component];
1571
enc_tid_component(Invalid, _State) ->
1572
error({invalid_id_list_component, Invalid}).
1574
enc_tid_sub_component(Sub, _State) ->
1577
choose -> ?megaco_choose;
1578
Char when integer(Char) -> Char
1581
%% mediaDescriptor = MediaToken LBRKT mediaParm *(COMMA mediaParm) RBRKT
1582
%% ; at-most-once per item
1583
%% ; and either streamParm or streamDescriptor but not both
1584
%% mediaParm = (streamParm / streamDescriptor /
1585
%% terminationStateDescriptor)
1587
%% streamParm = ( localDescriptor / remoteDescriptor /
1588
%% localControlDescriptor )
1589
%% streamDescriptor = StreamToken EQUAL StreamID LBRKT streamParm
1590
%% *(COMMA streamParm) RBRKT
1591
enc_MediaDescriptor(Val, State)
1592
when record(Val, 'MediaDescriptor') ->
1595
?LBRKT_INDENT(State),
1596
enc_list([{[Val#'MediaDescriptor'.termStateDescr],
1597
fun enc_TerminationStateDescriptor/2} |
1598
decompose_streams(Val#'MediaDescriptor'.streams)],
1599
?INC_INDENT(State)),
1600
?RBRKT_INDENT(State)
1603
decompose_streams(asn1_NOVALUE) ->
1605
decompose_streams({'MediaDescriptor_streams',Val}) ->
1606
decompose_streams(Val);
1607
decompose_streams({Tag, Val}) ->
1610
decompose_StreamParms(Val);
1612
[{Val, fun enc_StreamDescriptor/2}];
1614
error({invalid_streams_tag, Tag})
1617
decompose_StreamParms(Val)
1618
when record(Val, 'StreamParms') ->
1620
{[Val#'StreamParms'.localControlDescriptor],
1621
fun enc_LocalControlDescriptor/2},
1622
{[Val#'StreamParms'.localDescriptor],
1623
fun enc_localDescriptor/2},
1624
{[Val#'StreamParms'.remoteDescriptor],
1625
fun enc_remoteDescriptor/2},
1626
{[Val#'StreamParms'.statisticsDescriptor],
1627
fun enc_StatisticsDescriptor/2}
1630
enc_StreamDescriptor(Val, State)
1631
when record(Val, 'StreamDescriptor') ->
1635
enc_StreamID(Val#'StreamDescriptor'.streamID, State),
1636
?LBRKT_INDENT(State),
1637
enc_list(decompose_StreamParms(Val#'StreamDescriptor'.streamParms),
1638
?INC_INDENT(State)),
1639
?RBRKT_INDENT(State)
1642
%% localControlDescriptor = LocalControlToken LBRKT localParm
1643
%% *(COMMA localParm) RBRKT
1645
%% ; at-most-once per item
1646
%% localParm = ( streamMode / propertyParm /
1647
%% reservedValueMode / reservedGroupMode )
1648
%% reservedValueMode = ReservedValueToken EQUAL ( "ON" / "OFF" )
1649
%% reservedGroupMode = ReservedGroupToken EQUAL ( "ON" / "OFF" )
1651
%% reservedMode = ReservedToken EQUAL ( "ON" / "OFF" )
1653
%% streamMode = ModeToken EQUAL streamModes
1654
enc_LocalControlDescriptor(Val, State)
1655
when record(Val, 'LocalControlDescriptor') ->
1658
?LBRKT_INDENT(State),
1659
enc_list([{[Val#'LocalControlDescriptor'.streamMode],
1660
fun enc_StreamMode/2},
1661
{[Val#'LocalControlDescriptor'.reserveGroup],
1662
fun enc_reservedGroupMode/2},
1663
{[Val#'LocalControlDescriptor'.reserveValue],
1664
fun enc_reservedValueMode/2},
1665
{Val#'LocalControlDescriptor'.propertyParms,
1666
fun enc_PropertyParm/2}],
1667
?INC_INDENT(State)),
1668
?RBRKT_INDENT(State)
1671
enc_reservedGroupMode(Val, _State) ->
1673
?ReservedGroupToken,
1681
enc_reservedValueMode(Val, _State) ->
1683
?ReservedValueToken,
1691
enc_StreamMode({'StreamMode',Val}, State) ->
1692
enc_StreamMode(Val, State);
1693
enc_StreamMode(Val, _State) ->
1698
sendOnly -> ?SendonlyToken;
1699
recvOnly -> ?RecvonlyToken;
1700
sendRecv -> ?SendrecvToken;
1701
inactive -> ?InactiveToken;
1702
loopBack -> ?LoopbackToken
1706
enc_Name({'Name',Val}, State) ->
1707
enc_Name(Val, State);
1708
enc_Name(Val, State) ->
1709
%% BUGBUG: NAME = ALPHA *63(ALPHA / DIGIT / "_" )
1710
enc_STRING(Val, State, 1, 64).
1712
enc_PkgdName({'PkgdName', Val}, State) ->
1713
enc_PkgdName(Val, State);
1714
enc_PkgdName(Val, State) ->
1715
%% BUGBUG: pkgdName = (NAME / "*") SLASH (ItemID / "*" )
1716
enc_OCTET_STRING(Val, State, 1, 64).
1718
enc_localDescriptor(Val, State)
1719
when record(Val, 'LocalRemoteDescriptor') ->
1723
enc_LocalRemoteDescriptor(Val, State),
1724
?RBRKT_INDENT(State)
1727
enc_remoteDescriptor(Val, State)
1728
when record(Val, 'LocalRemoteDescriptor') ->
1732
enc_LocalRemoteDescriptor(Val, State),
1733
?RBRKT_INDENT(State)
1736
%% When text encoding the protocol, the descriptors consist of session
1737
%% descriptions as defined in SDP (RFC2327), except that the "s=", "t="
1738
%% and "o=" lines are optional. When multiple session descriptions are
1739
%% provided in one descriptor, the "v=" lines are required as delimiters;
1740
%% otherwise they are optional. Implementations shall accept session
1741
%% descriptions that are fully conformant to RFC2327. When binary
1742
%% encoding the protocol the descriptor consists of groups of properties
1743
%% (tag-value pairs) as specified in Annex C. Each such group may
1744
%% contain the parameters of a session description.
1745
enc_LocalRemoteDescriptor(Val, State)
1746
when record(Val, 'LocalRemoteDescriptor') ->
1747
case Val#'LocalRemoteDescriptor'.propGrps of
1752
enc_PropertyGroup(OptV, opt_v, State) |
1753
[enc_PropertyGroup(M, mand_v, State) || M <- MandV]]
1756
enc_PropertyGroup({'PropertyGroup',Val}, RequiresV, State) ->
1757
enc_PropertyGroup(Val, RequiresV, State);
1758
enc_PropertyGroup([H | _T] = List, mand_v, State)
1759
when record(H, 'PropertyParm'), H#'PropertyParm'.name == "v" ->
1760
enc_PropertyGroup(List, opt_v, State);
1761
enc_PropertyGroup(PG, opt_v, State) ->
1763
[[enc_PropertyGroupParm(PP, State), ?CrToken, ?LfToken] || PP <- PG]
1766
enc_PropertyGroupParm(Val, State)
1767
when record(Val, 'PropertyParm') ->
1768
[OctetString] = Val#'PropertyParm'.value,
1770
enc_PkgdName(Val#'PropertyParm'.name, State),
1772
enc_OCTET_STRING(OctetString, State, 0, infinity)
1775
%% propertyParm = pkgdName parmValue
1776
%% parmValue = (EQUAL alternativeValue/ INEQUAL VALUE)
1777
%% alternativeValue = ( VALUE / LSBRKT VALUE *(COMMA VALUE) RSBRKT /
1778
%% LSBRKT VALUE DOT DOT VALUE RSBRKT )
1779
enc_PropertyParm(Val, State)
1780
when record(Val, 'PropertyParm') ->
1781
PkgdName = ?META_ENC(property, Val#'PropertyParm'.name),
1783
enc_PkgdName(PkgdName, State),
1784
enc_propertyParmValues(Val#'PropertyParm'.value,
1785
Val#'PropertyParm'.extraInfo,
1789
enc_propertyParmValues([Single], asn1_NOVALUE, State) ->
1792
enc_Value(Single, State)
1794
enc_propertyParmValues([Single], {relation, Rel}, State) ->
1796
greaterThan -> [$>, enc_Value(Single, State)];
1797
smallerThan -> [$<, enc_Value(Single, State)];
1798
unequalTo -> [$#, enc_Value(Single, State)]
1800
enc_propertyParmValues([Low, High], {range, true}, State)->
1805
enc_Value(Low, State),
1807
enc_Value(High, State),
1810
enc_propertyParmValues(Values, {sublist, true}, State)->
1811
%% sublist (i.e. A AND B AND ...)
1814
?LSBRKT_INDENT(State),
1815
enc_list([{Values, fun enc_Value/2}], ?INC_INDENT(State)),
1816
?RSBRKT_INDENT(State)
1818
enc_propertyParmValues(Values, {sublist, false}, State) ->
1819
%% alternatives (i.e. A OR B OR ...)
1822
?LBRKT_INDENT(State),
1823
enc_list([{Values, fun enc_Value/2}], ?INC_INDENT(State)),
1824
?RBRKT_INDENT(State)
1826
enc_propertyParmValues(V, EI, _State) ->
1827
error({invalid_property_parm_values, V, EI}).
1829
enc_TerminationStateDescriptor(Val, State)
1830
when record(Val, 'TerminationStateDescriptor') ->
1832
?TerminationStateToken,
1833
?LBRKT_INDENT(State),
1834
enc_list([{Val#'TerminationStateDescriptor'.propertyParms,
1835
fun enc_PropertyParm/2},
1836
{[Val#'TerminationStateDescriptor'.eventBufferControl],
1837
fun enc_eventBufferControl/2},
1838
{[Val#'TerminationStateDescriptor'.serviceState],
1839
fun enc_serviceState/2}],
1840
?INC_INDENT(State)),
1841
?RBRKT_INDENT(State)
1844
enc_eventBufferControl(Val, _State) ->
1851
lockStep -> ?LockStepToken
1855
enc_serviceState({'ServiceState',Val}, State) ->
1856
enc_serviceState(Val, State);
1857
enc_serviceState(Val, _State) ->
1859
?ServiceStatesToken,
1863
outOfSvc -> ?OutOfSvcToken;
1864
inSvc -> ?InSvcToken
1868
enc_MuxDescriptor(Val, State)
1869
when record(Val, 'MuxDescriptor') ->
1873
enc_MuxType(Val#'MuxDescriptor'.muxType, State),
1874
enc_TerminationIDList1(Val#'MuxDescriptor'.termList, State)
1877
enc_MuxType({'MuxType',Val}, State) ->
1878
enc_MuxType(Val, State);
1879
enc_MuxType(Val, _State) ->
1885
%% extensionParameter
1886
nx64k -> ?Nx64kToken % v2
1889
enc_StreamID({'StreamID',Val}, State) ->
1890
enc_StreamID(Val, State);
1891
enc_StreamID(Val, State) ->
1892
enc_UINT16(Val, State).
1894
enc_EventsDescriptor(Val, State)
1895
when record(Val, 'EventsDescriptor') ->
1896
#'EventsDescriptor'{requestID = RequestId,
1897
eventList = Events} = Val,
1899
RequestId == asn1_NOVALUE, Events == [] ->
1904
RequestId /= asn1_NOVALUE, Events /= [] ->
1908
enc_RequestID(RequestId, State),
1909
?LBRKT_INDENT(State),
1910
enc_list([{Events, fun enc_RequestedEvent/2}],
1911
?INC_INDENT(State)),
1912
?RBRKT_INDENT(State)
1916
enc_RequestedEvent(Val, State)
1917
when record(Val, 'RequestedEvent') ->
1918
PkgdName = ?META_ENC(event, Val#'RequestedEvent'.pkgdName),
1920
enc_PkgdName(PkgdName, State),
1922
enc_list([{[Val#'RequestedEvent'.streamID], fun enc_eventStream/2},
1923
{Val#'RequestedEvent'.evParList, fun enc_eventOther/2} |
1924
decompose_requestedActions(Val#'RequestedEvent'.eventAction)],
1925
?INC_INDENT(State)),
1929
decompose_requestedActions(asn1_NOVALUE) ->
1933
%% This in the ABNF:
1934
%% at-most-once each of KeepActiveToken , eventDM and eventStream
1935
%% at most one of either embedWithSig or embedNoSig but not both
1936
%% KeepActiveToken and embedWithSig must not both be present
1940
decompose_requestedActions(#'RequestedActions'{keepActive = KA,
1943
signalsDescriptor = SD})
1945
SD /= asn1_NOVALUE, SD /= [] ->
1947
{[EDM], fun enc_EventDM/2},
1948
{[{SE, SD}], fun enc_embedWithSig/2}
1952
decompose_requestedActions(#'RequestedActions'{keepActive = KA,
1955
signalsDescriptor = SD})
1956
when SD == asn1_NOVALUE; SD == [] ->
1958
{[KA], fun enc_keepActive/2},
1959
{[EDM], fun enc_EventDM/2},
1960
{[SE], fun enc_embedNoSig/2}
1963
%% Fallback, if everything else failes....
1964
decompose_requestedActions(#'RequestedActions'{keepActive = KA,
1967
signalsDescriptor = SD}) ->
1969
{[KA], fun enc_keepActive/2},
1970
{[EDM], fun enc_EventDM/2},
1971
{[{SE, SD}], fun enc_embedWithSig/2}
1974
enc_embedNoSig(#'SecondEventsDescriptor'{requestID = RID,
1975
eventList = Evs}, State) ->
1978
?LBRKT_INDENT(State),
1979
enc_embedFirst(RID, Evs, ?INC_INDENT(State)),
1980
?RBRKT_INDENT(State)
1983
enc_embedWithSig({asn1_NOVALUE, SD}, State) ->
1986
?LBRKT_INDENT(State),
1987
enc_SignalsDescriptor(SD, ?INC_INDENT(State)),
1988
?RBRKT_INDENT(State)
1990
enc_embedWithSig({#'SecondEventsDescriptor'{requestID = RID,
1991
eventList = Evs}, SD}, State) ->
1994
?LBRKT_INDENT(State),
1995
enc_SignalsDescriptor(SD, ?INC_INDENT(State)),
1996
?COMMA_INDENT(?INC_INDENT(State)),
1997
enc_embedFirst(RID, Evs, ?INC_INDENT(State)),
1998
?RBRKT_INDENT(State)
2001
enc_keepActive(Val, _State) ->
2003
true -> [?KeepActiveToken];
2007
enc_EventDM({'EventDM',Val}, State) ->
2008
enc_EventDM(Val, State);
2009
enc_EventDM({Tag, Val}, State) ->
2015
enc_DigitMapName(Val, State)
2020
?LBRKT_INDENT(State),
2021
enc_DigitMapValue(Val, ?INC_INDENT(State)),
2022
?RBRKT_INDENT(State)
2025
error({invalid_EventDM_tag, Tag})
2029
enc_embedFirst(RID, Evs, State)
2030
when RID /= asn1_NOVALUE, list(Evs), Evs /= [] ->
2031
%% d("enc_embedFirst -> entry with"
2033
%% "~n Evs: ~p", [RID, Evs]),
2037
enc_RequestID(RID, State),
2038
?LBRKT_INDENT(State),
2039
enc_list([{Evs, fun enc_SecondRequestedEvent/2}], ?INC_INDENT(State)),
2040
?RBRKT_INDENT(State)
2042
enc_embedFirst(_RID, _Evs, State) ->
2043
%% d("enc_embedFirst -> entry"),
2049
enc_SecondRequestedEvent(#'SecondRequestedEvent'{pkgdName = N,
2052
eventAction = EA}, State) ->
2053
PkgdName = ?META_ENC(event, N),
2055
enc_PkgdName(PkgdName, State),
2058
[{[SID], fun enc_eventStream/2},
2059
{EPL, fun enc_eventOther/2} |
2060
decompose_secondRequestedActions(EA)],
2061
?INC_INDENT(State)),
2065
decompose_secondRequestedActions(asn1_NOVALUE) ->
2067
decompose_secondRequestedActions(Val)
2068
when record(Val, 'SecondRequestedActions') ->
2070
{[Val#'SecondRequestedActions'.keepActive],
2071
fun enc_keepActive/2},
2072
{[Val#'SecondRequestedActions'.eventDM],
2074
{[Val#'SecondRequestedActions'.signalsDescriptor],
2075
fun enc_embeddedSignalsDescriptor/2}
2078
enc_embeddedSignalsDescriptor(Val, State) ->
2081
?LBRKT_INDENT(State),
2082
enc_SignalsDescriptor(Val, ?INC_INDENT(State)),
2083
?RBRKT_INDENT(State)
2086
enc_EventBufferDescriptor({'EventBufferDescriptor',Val}, State) ->
2087
enc_EventBufferDescriptor(Val, State);
2088
enc_EventBufferDescriptor([Mand | Opt], State) ->
2091
?LBRKT_INDENT(State),
2092
enc_eventSpecs([Mand | Opt], ?INC_INDENT(State)),
2093
?RBRKT_INDENT(State)
2096
enc_eventSpecs([Mand | Opt], State) ->
2097
[enc_eventSpecs(Mand, State),
2098
[[?COMMA_INDENT(State), enc_eventSpec(Val, State)] || Val <- Opt]].
2100
enc_eventSpec(Val, State)
2101
when record(Val, 'EventSpec') ->
2103
enc_EventName(Val#'EventSpec'.eventName, State),
2105
enc_list([{[Val#'EventSpec'.streamID], fun enc_eventStream/2},
2106
{Val#'EventSpec'.eventParList, fun enc_eventOther/2}],
2107
?INC_INDENT(State)),
2111
enc_SignalsDescriptor({'SignalsDescriptor',Val}, State) ->
2112
enc_SignalsDescriptor(Val, State);
2113
enc_SignalsDescriptor([], _State) ->
2117
enc_SignalsDescriptor(List, State) when list(List) ->
2120
?LBRKT_INDENT(State),
2121
enc_list([{List, fun enc_SignalRequest/2}], ?INC_INDENT(State)),
2122
?RBRKT_INDENT(State)
2125
enc_SignalRequest({'SignalRequest',Val}, State) ->
2126
enc_SignalRequest(Val, State);
2127
enc_SignalRequest({Tag, Val}, State) ->
2130
enc_Signal(Val, State);
2132
enc_SeqSigList(Val, State);
2134
error({invalid_SignalRequest_tag, Tag})
2138
enc_SeqSigList(Val, State)
2139
when record(Val, 'SeqSigList') ->
2143
enc_UINT16(Val#'SeqSigList'.id, State),
2144
?LBRKT_INDENT(State),
2145
enc_list([{Val#'SeqSigList'.signalList, fun enc_Signal/2}],
2146
?INC_INDENT(State)),
2147
?RBRKT_INDENT(State)
2150
enc_Signal(Val, State)
2151
when record(Val, 'Signal') ->
2153
enc_SignalName(Val#'Signal'.signalName, State),
2155
enc_list([{[Val#'Signal'.streamID], fun enc_sigStream/2},
2156
{[Val#'Signal'.sigType], fun enc_sigSignalType/2},
2157
{[Val#'Signal'.duration], fun enc_sigDuration/2},
2158
{[Val#'Signal'.notifyCompletion], fun enc_notifyCompletion/2},
2159
{[Val#'Signal'.keepActive], fun enc_keepActive/2},
2160
{Val#'Signal'.sigParList, fun enc_sigOther/2},
2161
{[Val#'Signal'.direction], fun enc_SignalDirection/2},
2162
{[Val#'Signal'.requestID], fun enc_sigRequestID/2}],
2163
?INC_INDENT(State)),
2167
enc_sigStream(Val, State) ->
2171
enc_StreamID(Val, State)
2174
enc_sigSignalType(Val, State) ->
2178
enc_SignalType(Val, State)
2181
enc_sigDuration(Val, State) ->
2185
enc_UINT16(Val, State)
2188
enc_notifyCompletion(List, State) when list(List) ->
2190
?NotifyCompletionToken,
2192
?LBRKT_INDENT(State),
2193
enc_list([{List, fun enc_notifyCompletionItem/2}], ?INC_INDENT(State)),
2194
?RBRKT_INDENT(State)
2197
enc_notifyCompletionItem(Val, _State) ->
2199
onTimeOut -> ?TimeOutToken;
2200
onInterruptByEvent -> ?InterruptByEventToken;
2201
onInterruptByNewSignalDescr -> ?InterruptByNewSignalsDescrToken;
2202
otherReason -> ?OtherReasonToken
2205
enc_SignalType({'SignalType',Val}, State) ->
2206
enc_SignalType(Val, State);
2207
enc_SignalType(Val, _State) ->
2209
brief -> ?BriefToken;
2210
onOff -> ?OnOffToken;
2211
timeOut -> ?TimeOutToken
2214
enc_SignalName({'SignalName',Val}, State)->
2215
enc_SignalName(Val, State);
2216
enc_SignalName(Val, State) ->
2217
PkgdName = ?META_ENC(signal, Val),
2218
enc_PkgdName(PkgdName, State).
2220
enc_sigOther(Val, State)
2221
when record(Val, 'SigParameter') ->
2223
enc_Name(Val#'SigParameter'.sigParameterName, State),
2224
enc_propertyParmValues(Val#'SigParameter'.value,
2225
Val#'SigParameter'.extraInfo,
2229
enc_SignalDirection({'SignalDirection', Val}, State) ->
2230
enc_SignalDirection(Val, State);
2231
enc_SignalDirection(Val, _State) ->
2236
internal -> ?InternalToken;
2237
external -> ?ExternalToken;
2242
enc_sigRequestID(Val, State) ->
2246
enc_RequestID(Val, State)
2249
enc_RequestID({'RequestID',Val}, State) ->
2250
enc_RequestID(Val, State);
2251
enc_RequestID(Val, _State) when Val == ?megaco_all_request_id ->
2253
enc_RequestID(Val, State) ->
2254
enc_UINT32(Val, State).
2256
enc_ModemDescriptor(MD, _State) ->
2257
error({deprecated, MD}).
2260
%% As of corr 1 ModemDescriptor has been deprecated.
2261
%% 7.1.2: ...shall not be included as part of a transmitted content and,
2262
%% if received, shall either be ignored or processed at the option
2263
%% of the implementation. ...
2264
%% enc_ModemDescriptor(#'ModemDescriptor'{mtl = [Val],
2266
%% nonStandardData = asn1_NOVALUE},
2271
%% enc_ModemType(Val, State)
2273
%% enc_ModemDescriptor(Val, State)
2274
%% when record(Val, 'ModemDescriptor') ->
2278
%% enc_list([{Val#'ModemDescriptor'.mtl, fun enc_ModemType/2}], State),
2280
%% enc_opt_brackets(
2281
%% enc_list([{Val#'ModemDescriptor'.mpl, fun enc_PropertyParm/2}],
2282
%% ?INC_INDENT(State)),
2284
%% %% BUGBUG: Is PropertyParm == NAME parmValue?
2287
%% enc_ModemDescriptor(Val, State)
2288
%% when record(Val, 'ModemDescriptor') ->
2291
%% %% BUGBUG: Does never generate: EQUAL modemType
2293
%% enc_list([{Val#'ModemDescriptor'.mtl, fun enc_ModemType/2}], State),
2295
%% enc_opt_brackets(
2296
%% enc_list([{Val#'ModemDescriptor'.mpl, fun enc_PropertyParm/2}],
2297
%% ?INC_INDENT(State)),
2299
%% %% BUGBUG: Is PropertyParm == NAME parmValue?
2302
%% Corr1: See ModemDescriptor above
2303
%% enc_ModemType({'ModemType',Val}, State)->
2304
%% enc_ModemType(Val, State);
2305
%% enc_ModemType(Val, _State) ->
2306
%% %% BUGBUG: Does not handle extensionParameter
2308
%% v18 -> ?V18Token;
2309
%% v22 -> ?V22Token;
2310
%% v22bis -> ?V22bisToken;
2311
%% v32 -> ?V32Token;
2312
%% v32bis -> ?V32bisToken;
2313
%% v34 -> ?V34Token;
2314
%% v90 -> ?V90Token;
2315
%% v91 -> ?V91Token;
2316
%% synchISDN -> ?SynchISDNToken
2319
enc_DigitMapDescriptor(Val, State)
2320
when record(Val, 'DigitMapDescriptor') ->
2324
enc_DigitMapName(Val#'DigitMapDescriptor'.digitMapName, State),
2325
?LBRKT_INDENT(State),
2326
enc_DigitMapValue(Val#'DigitMapDescriptor'.digitMapValue,
2327
?INC_INDENT(State)),
2328
?RBRKT_INDENT(State)
2331
enc_DigitMapName({'DigitMapName',Val}, State) ->
2332
enc_DigitMapName(Val, State);
2333
enc_DigitMapName(Val, State) ->
2334
enc_Name(Val, State).
2336
enc_DigitMapValue(Val, State)
2337
when record(Val, 'DigitMapValue') ->
2339
enc_timer(Val#'DigitMapValue'.startTimer, $T, State),
2340
enc_timer(Val#'DigitMapValue'.shortTimer, $S, State),
2341
enc_timer(Val#'DigitMapValue'.longTimer, $L, State),
2342
enc_timer(Val#'DigitMapValue'.durationTimer, $Z, State),
2343
%% BUGBUG: digitMapBody not handled at all
2344
enc_STRING(Val#'DigitMapValue'.digitMapBody, State, 0, infinity)
2347
enc_timer(asn1_NOVALUE, _Prefix, _State) ->
2349
enc_timer(Timer, Prefix, State) ->
2353
enc_DIGIT(Timer, State, 0, 99),
2354
?COMMA_INDENT(State)
2357
enc_ServiceChangeParm(Val, State)
2358
when record(Val, 'ServiceChangeParm') ->
2361
?LBRKT_INDENT(State),
2362
enc_list([{[Val#'ServiceChangeParm'.serviceChangeMethod],
2363
fun enc_ServiceChangeMethod/2},
2364
{[Val#'ServiceChangeParm'.serviceChangeAddress],
2365
fun enc_ServiceChangeAddress/2},
2366
{[Val#'ServiceChangeParm'.serviceChangeVersion],
2367
fun enc_serviceChangeVersion/2},
2368
{[Val#'ServiceChangeParm'.serviceChangeProfile],
2369
fun enc_ServiceChangeProfile/2},
2370
{[{reason, Val#'ServiceChangeParm'.serviceChangeReason}],
2371
fun enc_serviceChangeReason/2},
2372
{[Val#'ServiceChangeParm'.serviceChangeDelay],
2373
fun enc_serviceChangeDelay/2},
2374
{[Val#'ServiceChangeParm'.serviceChangeMgcId],
2375
fun enc_serviceChangeMgcId/2},
2376
{[Val#'ServiceChangeParm'.timeStamp],
2377
fun enc_TimeNotation/2},
2378
{Val#'ServiceChangeParm'.serviceChangeInfo,
2379
fun enc_AuditDescriptor/2},
2380
{[Val#'ServiceChangeParm'.serviceChangeIncompleteFlag],
2381
fun('NULL', _) -> ?ServiceChangeIncompleteToken end}],
2382
?INC_INDENT(State)),
2383
?RBRKT_INDENT(State)
2387
enc_ServiceChangeMethod({'ServiceChangeMethod',Val}, State) ->
2388
enc_ServiceChangeMethod(Val, State);
2389
enc_ServiceChangeMethod(Val, _State) ->
2394
failover -> ?FailoverToken;
2395
forced -> ?ForcedToken;
2396
graceful -> ?GracefulToken;
2397
restart -> ?RestartToken;
2398
disconnected -> ?DisconnectedToken;
2399
handOff -> ?HandOffToken
2401
%% BUGBUG: extension
2404
enc_ServiceChangeAddress({'ServiceChangeAddress',Val}, State) ->
2405
enc_ServiceChangeAddress(Val, State);
2406
enc_ServiceChangeAddress({Tag, Val}, State) ->
2408
?ServiceChangeAddressToken,
2412
enc_portNumber(Val, State);
2414
enc_IP4Address(Val, State);
2416
enc_IP6Address(Val, State);
2418
enc_DomainName(Val, State);
2420
enc_PathName(Val, State);
2422
enc_mtpAddress(Val, State);
2424
error({invalid_ServiceChangeAddress_tag, Tag})
2428
enc_serviceChangeVersion(Val, State) ->
2432
enc_version(Val, State)
2435
enc_ServiceChangeProfile(#'ServiceChangeProfile'{profileName = Name,
2441
enc_Name(Name, State),
2443
enc_version(Version, State)
2446
enc_serviceChangeReason({reason, Val}, State) ->
2450
[List] when list(List) ->
2454
enc_QUOTED_STRING(List,State) % OTP-4632 enc_Value(List, State)
2458
enc_serviceChangeDelay(Val, State) ->
2462
enc_UINT32(Val, State)
2465
enc_serviceChangeMgcId(Val, State) ->
2472
enc_portNumber(Val, State) when integer(Val), Val >= 0 ->
2473
enc_UINT16(Val, State).
2475
enc_ServiceChangeResParm(Val, State)
2476
when record(Val, 'ServiceChangeResParm') ->
2477
enc_list([{[Val#'ServiceChangeResParm'.serviceChangeAddress],
2478
fun enc_ServiceChangeAddress/2},
2479
{[Val#'ServiceChangeResParm'.serviceChangeVersion],
2480
fun enc_serviceChangeVersion/2},
2481
{[Val#'ServiceChangeResParm'.serviceChangeProfile],
2482
fun enc_ServiceChangeProfile/2},
2483
{[Val#'ServiceChangeResParm'.serviceChangeMgcId],
2484
fun enc_serviceChangeMgcId/2},
2485
{[Val#'ServiceChangeResParm'.timeStamp],
2486
fun enc_TimeNotation/2}],
2489
enc_PackagesDescriptor({'PackagesDescriptor',Val}, State) ->
2490
enc_PackagesDescriptor(Val, State);
2491
enc_PackagesDescriptor(Val, State) ->
2494
?LBRKT_INDENT(State),
2495
enc_list([{Val, fun enc_PackagesItem/2}], ?INC_INDENT(State)),
2496
?RBRKT_INDENT(State)
2499
enc_PackagesItem(Val, State)
2500
when record(Val, 'PackagesItem') ->
2501
PkgdName = ?META_ENC(package, Val#'PackagesItem'.packageName),
2503
enc_Name(PkgdName, State),
2505
enc_UINT16(Val#'PackagesItem'.packageVersion, State)
2508
enc_StatisticsDescriptor({'StatisticsDescriptor',Val}, State) ->
2509
enc_StatisticsDescriptor(Val, State);
2510
enc_StatisticsDescriptor(List, State) when list(List) ->
2513
?LBRKT_INDENT(State),
2514
enc_list([{List, fun enc_StatisticsParameter/2}], ?INC_INDENT(State)),
2515
?RBRKT_INDENT(State)
2518
enc_StatisticsParameter(Val, State)
2519
when record(Val, 'StatisticsParameter') ->
2520
PkgdName = ?META_ENC(statistics, Val#'StatisticsParameter'.statName),
2521
case Val#'StatisticsParameter'.statValue of
2524
enc_PkgdName(PkgdName, State)
2526
[StatVal] when list(StatVal) ->
2528
enc_PkgdName(PkgdName, State),
2530
enc_Value(StatVal, State)
2534
enc_TimeNotation(Val, State)
2535
when record(Val, 'TimeNotation') ->
2537
enc_STRING(Val#'TimeNotation'.date, State, 8, 8), % "yyyymmdd"
2539
enc_STRING(Val#'TimeNotation'.time, State, 8, 8) % "hhmmssss"
2542
%% BUGBUG: Does not verify that string must contain at least one char
2543
%% BUGBUG: This violation of the is required in order to comply with
2544
%% BUGBUG: the dd/ce ds parameter that may possibly be empty.
2545
enc_Value({'Value',Val}, State) ->
2546
enc_Value(Val, State);
2547
enc_Value(String, _State) ->
2548
case quoted_string_count(String, 0, true) of
2550
[?DQUOTE, String, ?DQUOTE];
2552
[?DQUOTE, String, ?DQUOTE];
2557
quoted_string_count([H | T], Count, IsSafe) ->
2558
case ?classify_char(H) of
2559
safe_char -> quoted_string_count(T, Count + 1, IsSafe);
2560
rest_char -> quoted_string_count(T, Count + 1, false);
2561
white_space -> quoted_string_count(T, Count + 1, false);
2562
_ -> error({illegal_char, H})
2564
quoted_string_count([], Count, IsSafe) ->
2567
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2569
%% Encode an octet string, escape } by \ if necessary
2570
enc_OCTET_STRING(List, State, Min, Max) ->
2571
do_enc_OCTET_STRING(List, State, Min, Max, 0).
2573
do_enc_OCTET_STRING([H | T], State, Min, Max, Count) ->
2576
[$\\, H | do_enc_OCTET_STRING(T, State, Min, Max, Count + 1)];
2578
[H | do_enc_OCTET_STRING(T, State, Min, Max, Count + 1)]
2580
do_enc_OCTET_STRING([], _State, Min, Max, Count) ->
2581
verify_count(Count, Min, Max),
2584
enc_QUOTED_STRING(String, _State) when list(String) ->
2585
{_IsSafe, Count} = quoted_string_count(String, 0, true),
2586
verify_count(Count, 1, infinity),
2587
[?DQUOTE, String, ?DQUOTE].
2589
%% The internal format of hex digits is a list of octets
2590
%% Min and Max means #hexDigits
2591
%% Leading zeros are prepended in order to fulfill Min
2592
enc_HEXDIG(Octets, State, Min, Max) when list(Octets) ->
2593
do_enc_HEXDIG(Octets, State, Min, Max, 0, []).
2595
do_enc_HEXDIG([Octet | Rest], State, Min, Max, Count, Acc)
2596
when Octet >= 0, Octet =< 255 ->
2597
Hex = hex(Octet), % OTP-4921
2600
Acc2 = [[$0|Hex]|Acc], % OTP-4921
2601
do_enc_HEXDIG(Rest, State, Min, Max, Count + 2, ["0" | Acc2]);
2603
Acc2 = [Hex|Acc], % OTP-4921
2604
do_enc_HEXDIG(Rest, State, Min, Max, Count + 2, Acc2)
2606
do_enc_HEXDIG([], State, Min, Max, Count, Acc)
2607
when integer(Min), Count < Min ->
2608
do_enc_HEXDIG([0], State, Min, Max, Count, Acc);
2609
do_enc_HEXDIG([], _State, Min, Max, Count, Acc) -> %% OTP-4710
2610
verify_count(Count, Min, Max),
2613
enc_DIGIT(Val, State, Min, Max) ->
2614
enc_integer(Val, State, Min, Max).
2616
enc_STRING(String, _State, Min, Max) when list(String) ->
2617
verify_count(length(String), Min, Max),
2620
enc_UINT16(Val, State) ->
2621
enc_integer(Val, State, 0, 65535).
2623
enc_UINT32(Val, State) ->
2624
enc_integer(Val, State, 0, 4294967295).
2626
enc_integer(Val, _State, Min, Max) ->
2627
verify_count(Val, Min, Max),
2628
integer_to_list(Val).
2630
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2631
%% Encodes a list of elements with separator tokens between
2632
%% the elements. Optional asn1_NOVALUE values are ignored.
2634
enc_list(List, State) ->
2635
enc_list(List, State, fun(S) -> ?COMMA_INDENT(S) end, false).
2637
enc_list([{Elems, ElemEncoder} | Tail], State, SepEncoder, NeedsSep) ->
2638
case do_enc_list(Elems, State, ElemEncoder, SepEncoder, NeedsSep) of
2640
enc_list(Tail, State, SepEncoder, NeedsSep);
2643
enc_list(Tail, State, SepEncoder, true)]
2645
enc_list([], _State, _SepEncoder, _NeedsSep) ->
2647
enc_list(asn1_NOVALUE, _State, _SepEncoder, _NeedsSep) ->
2649
enc_list(A, B, C, D) ->
2650
error({invalid_list, A, B, C, D}).
2652
do_enc_list(asn1_NOVALUE, _State, _ElemEncoder, _SepEncoder, _NeedsSep) ->
2654
do_enc_list([], _State, _ElemEncoder, _SepEncoder, _NeedsSep) ->
2656
do_enc_list([asn1_NOVALUE | T], State, ElemEncoder, SepEncoder, NeedsSep) ->
2657
do_enc_list(T, State, ElemEncoder, SepEncoder, NeedsSep);
2658
do_enc_list([H | T], State, ElemEncoder, SepEncoder, NeedsSep)
2659
when function(ElemEncoder), function(SepEncoder) ->
2660
case ElemEncoder(H, State) of
2662
do_enc_list(T, State, ElemEncoder, SepEncoder, NeedsSep);
2663
List when NeedsSep == true ->
2665
List, do_enc_list(T, State, ElemEncoder, SepEncoder, true)];
2666
List when NeedsSep == false ->
2668
do_enc_list(T, State, ElemEncoder, SepEncoder, true)]
2671
%% Add brackets if list is non-empty
2672
enc_opt_brackets([], _State) ->
2674
enc_opt_brackets(List, State) when list(List) ->
2675
[?LBRKT_INDENT(State), List, ?RBRKT_INDENT(State)].
2677
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2679
%% Int -> list of hex chars
2681
hexi(get_lo_bits(Int, 4), []).
2683
hexi({0, Lo}, Ack) ->
2685
hexi({Hi, Lo} , Ack) ->
2686
hexi(get_lo_bits(Hi, 4), [hex4(Lo) | Ack]).
2688
hex4(Int) when Int < 10 ->
2693
get_lo_bits(Int, Size) ->
2694
Lo = Int band ones_mask(Size),
2701
%% Verify that Count is within the range of Min and Max
2702
verify_count(Count, Min, Max) ->
2706
integer(Min), Count >= Min ->
2708
integer(Max), Count =< Max ->
2713
error({count_too_large, Count, Max})
2716
error({count_too_small, Count, Min})
2719
error({count_not_an_integer, Count})
2722
%% -------------------------------------------------------------------
2725
erlang:fault(Reason).
2728
%% -------------------------------------------------------------------
2733
%% d(get(dbg), F, A).
2736
%% io:format("~p:" ++ F ++ "~n", [?MODULE | A]);
added
removed
lib/megaco/src/text/megaco_text_gen_v3.hrl
