#include /* MEDIA-GATEWAY-CONTROL DEFINITIONS AUTOMATIC TAGS::= */ /* BEGIN */ #include "disp_megaco.h" void disp_BOOLEAN(ASN1_Boolean_t Boolean) { printf("%s - begin\n", __func__); if(Boolean == false) { printf("FALSE\n"); } else { printf("TRUE\n"); } printf("%s - end\n", __func__); return; } void disp_BIT_STRING(ASN1_BitString_t BitString) { printf("%s - begin\n", __func__); if(BitString.value != NULL) { printf("length (bits): %zd\n", BitString.length); for(size_t i = 0; i < (BitString.length + 7)/8; i++) { printf("%02X\n", (unsigned int)BitString.value[i]); } } if(BitString.segment != NULL) { disp_BIT_STRING(*BitString.segment); } printf("%s - end\n", __func__); return; } void disp_OCTET_STRING(ASN1_OctetString_t OctetString) { printf("%s - begin\n", __func__); if(OctetString.value != NULL) { printf("length (octets): %zd\n", OctetString.length); for(size_t i = 0; i < OctetString.length; i++) { printf("%u\n", (unsigned int)OctetString.value[i]); } } if(OctetString.segment != NULL) { disp_OCTET_STRING(*OctetString.segment); } printf("%s - end\n", __func__); return; } void disp_IA5String(ASN1_IA5String_t IA5String) { printf("%s - begin\n", __func__); if(IA5String.value != NULL) { printf("characters: %zd\n", IA5String.characters); for(size_t i = 0; i < IA5String.characters; i++) { printf("%u\n", (unsigned int)IA5String.value[i]); } } if(IA5String.segment != NULL) { disp_IA5String(*IA5String.segment); } printf("%s - end\n", __func__); return; } void disp_INTEGER(ASN1_Integer_t Integer) { printf("%s - begin\n", __func__); printf("%jd\n", Integer); printf("%s - end\n", __func__); return; } void disp_ENUMERATED(ASN1_Enumerated_t Enum) { printf("%s - begin\n", __func__); printf("%d\n", Enum); printf("%s - end\n", __func__); return; } void disp_OBJECT_IDENTIFIER(ASN1_ObjectIdentifier_t ObjectIdentifier) { printf("%s - begin\n", __func__); if(ObjectIdentifier.regno == 0) { for(size_t i = 0; i < ObjectIdentifier.NumberOfObjIdComponents; i++) { printf("%u\n", ObjectIdentifier.ObjIdComponentsList[i]); } } else { printf("regno %u\n", ObjectIdentifier.regno); } printf("%s - end\n", __func__); return; } /* MegacoMessage ::= SEQUENCE */ /* { */ /* authHeader AuthenticationHeader OPTIONAL, */ /* mess Message */ /* } */ void disp_MegacoMessage(MegacoMessage__t MegacoMessage) { printf("MegacoMessage - begin\n"); if(MegacoMessage.authHeader != NULL) { printf("authHeader:\n"); disp_AuthenticationHeader(*MegacoMessage.authHeader); } else { printf("authHeader: -absent-\n"); } disp_Message(MegacoMessage.mess); printf("MegacoMessage - end\n"); return; } /* AuthenticationHeader ::= SEQUENCE */ /* { */ /* secParmIndex SecurityParmIndex, */ /* seqNum SequenceNum, */ /* ad AuthData */ /* } */ void disp_AuthenticationHeader(AuthenticationHeader__t AuthenticationHeader) { printf("AuthenticationHeader - begin\n"); disp_SecurityParmIndex(AuthenticationHeader.secParmIndex); disp_SequenceNum(AuthenticationHeader.seqNum); disp_AuthData(AuthenticationHeader.ad); printf("AuthenticationHeader - end\n"); return; } /* SecurityParmIndex ::= OCTET STRING(SIZE(4)) */ void disp_SecurityParmIndex(SecurityParmIndex__t SecurityParmIndex) { printf("SecurityParmIndex - begin\n"); disp_OCTET_STRING(SecurityParmIndex); printf("SecurityParmIndex - end\n"); return; } /* SequenceNum ::= OCTET STRING(SIZE(4)) */ void disp_SequenceNum(SequenceNum__t SequenceNum) { printf("SequenceNum - begin\n"); disp_OCTET_STRING(SequenceNum); printf("SequenceNum - end\n"); return; } /* AuthData ::= OCTET STRING (SIZE (12..32)) */ void disp_AuthData(AuthData__t AuthData) { printf("AuthData - begin\n"); disp_OCTET_STRING(AuthData); printf("AuthData - end\n"); return; } /* Message ::= SEQUENCE */ /* { */ /* version INTEGER(0..99), */ /* -- The version of the protocol defined here is equal to 1. */ /* mId MId, -- Name/address of message originator */ /* messageBody CHOICE */ /* { */ /* messageError ErrorDescriptor, */ /* transactions SEQUENCE OF Transaction */ /* }, */ /* ... */ /* } */ void disp_Message(Message__t Message) { printf("Message - begin\n"); printf("version: %jd\n", Message.version); printf("mId:\n"); disp_MId(Message.mId); printf("messageBody\n"); switch(Alternative(Message.messageBody)) { case 1: { printf("messageError\n"); disp_ErrorDescriptor(*Message.messageBody.messageError); break; } case 2: { printf("transactions * %zd\n", Instances(Message.messageBody.transactions)); for(size_t i = 1; i <= Instances(Message.messageBody.transactions); i++) { disp_Transaction(Message.messageBody.transactions[i]); } break; } default: { printf("Error!!! %s\n", __func__); } } printf("Message - end\n"); return; } /* MId ::= CHOICE */ /* { */ /* ip4Address IP4Address, */ /* ip6Address IP6Address, */ /* domainName DomainName, */ /* deviceName PathName, */ /* mtpAddress OCTET STRING(SIZE(2..4)), */ /* -- Addressing structure of mtpAddress: */ /* -- 15 0 */ /* -- | PC | NI | */ /* -- 14 bits 2 bits */ /* ... */ /* } */ void disp_MId(MId__t MId) { printf("MId - begin\n"); switch(Alternative(MId)) { case 1: /* ip4Address */ { printf("ip4Address\n"); disp_IP4Address(*MId.ip4Address); break; } case 2: /* ip6Address */ { printf("ip6Address\n"); disp_IP6Address(*MId.ip6Address); break; } case 3: /* domainName */ { printf("domainName\n"); disp_DomainName(*MId.domainName); break; } case 4: /* deviceName */ { printf("deviceName\n"); disp_PathName(*MId.deviceName); break; } case 5: /* mtpAddress */ { printf("mtpAddress\n"); disp_OCTET_STRING(*MId.mtpAddress); break; } default: { printf("Error!!! %s\n", __func__); } } printf("MId - end\n"); return; } /* DomainName ::= SEQUENCE */ /* { */ /* name IA5String, */ /* -- The name starts with an alphanumeric digit followed by a */ /* -- sequence of alphanumeric digits, hyphens and dots. No two */ /* -- dots shall occur consecutively. */ /* portNumber INTEGER(0..65535) OPTIONAL */ /* } */ void disp_DomainName(DomainName__t DomainName) { printf("DomainName - begin\n"); disp_IA5String(DomainName.name); if(DomainName.portNumber != NULL) { printf("portNumber: %jd\n", *DomainName.portNumber); } else { printf("portNumber: -absent-\n"); } printf("DomainName - end\n"); return; } /* IP4Address ::= SEQUENCE */ /* { */ /* address OCTET STRING (SIZE(4)), */ /* portNumber INTEGER(0..65535) OPTIONAL */ /* } */ void disp_IP4Address(IP4Address__t IP4Address) { printf("IP4Address - begin\n"); disp_OCTET_STRING(IP4Address.address); if(IP4Address.portNumber != NULL) { printf("portNumber: %jd\n", *IP4Address.portNumber); } else { printf("portNumber: -absent-\n"); } printf("IP4Address - end\n"); return; } /* IP6Address ::= SEQUENCE */ /* { */ /* address OCTET STRING (SIZE(16)), */ /* portNumber INTEGER(0..65535) OPTIONAL */ /* } */ void disp_IP6Address(IP6Address__t IP6Address) { printf("IP6Address - begin\n"); disp_OCTET_STRING(IP6Address.address); if(IP6Address.portNumber != NULL) { printf("portNumber: %jd\n", *IP6Address.portNumber); } else { printf("portNumber: -absent-\n"); } printf("IP6Address - end\n"); return; } /* PathName ::= IA5String(SIZE (1..64)) */ /* -- See section A.3 */ void disp_PathName(PathName__t PathName) { printf("PathName - begin\n"); disp_IA5String(PathName); printf("PathName - end\n"); return; } /* Transaction ::= CHOICE */ /* { */ /* transactionRequest TransactionRequest, */ /* transactionPending TransactionPending, */ /* transactionReply TransactionReply, */ /* transactionResponseAck TransactionResponseAck, */ /* -- use of response acks is dependent on underlying transport */ /* ... */ /* } */ void disp_Transaction(Transaction__t Transaction) { printf("Transaction - begin\n"); switch(Alternative(Transaction)) { case 1: { printf("transactionRequest:\n"); disp_TransactionRequest(*Transaction.transactionRequest); break; } case 2: { printf("transactionPending:\n"); disp_TransactionPending(*Transaction.transactionPending); break; } case 3: { printf("transactionReply:\n"); disp_TransactionReply(*Transaction.transactionReply); break; } case 4: { printf("transactionResponseAck:\n"); disp_TransactionResponseAck(Transaction.transactionResponseAck); break; } default: { printf("Error!!! %s\n", __func__); } } printf("Transaction - end\n"); return; } /* TransactionId ::= INTEGER(0..4294967295) -- 32 bit unsigned integer */ void disp_TransactionId(TransactionId__t TransactionId) { printf("%s - begin\n", __func__); printf("%jd\n", TransactionId); printf("%s - end\n", __func__); return; } /* TransactionRequest ::= SEQUENCE */ /* { */ /* transactionId TransactionId, */ /* actions SEQUENCE OF ActionRequest, */ /* ... */ /* } */ void disp_TransactionRequest(TransactionRequest__t TransactionRequest) { printf("%s - begin\n", __func__); printf("transactionId:\n"); disp_TransactionId(TransactionRequest.transactionId); printf("actions * %zd\n", Instances(TransactionRequest.actions)); for(size_t i = 1; i <= Instances(TransactionRequest.actions); i++) { disp_ActionRequest(TransactionRequest.actions[i]); } printf("%s - end\n", __func__); return; } /* TransactionPending ::= SEQUENCE */ /* { */ /* transactionId TransactionId, */ /* ... */ /* } */ void disp_TransactionPending(TransactionPending__t TransactionPending) { printf("%s - begin\n", __func__); disp_TransactionId(TransactionPending.transactionId); printf("%s - end\n", __func__); return; } /* TransactionReply ::= SEQUENCE */ /* { */ /* transactionId TransactionId, */ /* immAckRequired NULL OPTIONAL, */ /* transactionResult CHOICE */ /* { */ /* transactionError ErrorDescriptor, */ /* actionReplies SEQUENCE OF ActionReply */ /* }, */ /* ... */ /* } */ void disp_TransactionReply(TransactionReply__t TransactionReply) { printf("%s - begin\n", __func__); disp_TransactionId(TransactionReply.transactionId); if(TransactionReply.immAckRequired != NULL) { printf("immAckRequired -present- \n"); } else { printf("immAckRequired -absent- \n"); } switch(Alternative(TransactionReply.transactionResult)) { case 1: { printf("transactionError\n"); disp_ErrorDescriptor(*TransactionReply.transactionResult.transactionError); break; } case 2: { printf("actionReplies * %zd\n", Instances(TransactionReply.transactionResult.actionReplies)); for(size_t i = 1; i <= Instances(TransactionReply.transactionResult.actionReplies); i++) { disp_ActionReply(TransactionReply.transactionResult.actionReplies[i]); } break; } default: { printf("Error!!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* TransactionResponseAck ::= SEQUENCE OF TransactionAck */ void disp_TransactionResponseAck(TransactionResponseAck__t TransactionResponseAck) { printf("%s - begin\n", __func__); printf("* %zd\n", Instances(TransactionResponseAck)); for(size_t i = 1; i <= Instances(TransactionResponseAck); i++) { disp_TransactionAck(TransactionResponseAck[i]); } printf("%s - end\n", __func__); return; } /* TransactionAck ::= SEQUENCE */ /* { */ /* firstAck TransactionId, */ /* lastAck TransactionId OPTIONAL */ /* } */ void disp_TransactionAck(TransactionAck__t TransactionAck) { printf("%s - begin\n", __func__); disp_TransactionId(TransactionAck.firstAck); if(TransactionAck.lastAck != NULL) { disp_TransactionId(*TransactionAck.lastAck); } printf("%s - end\n", __func__); return; } /* ErrorDescriptor ::= SEQUENCE */ /* { */ /* errorCode ErrorCode, */ /* errorText ErrorText OPTIONAL */ /* } */ void disp_ErrorDescriptor(ErrorDescriptor__t ErrorDescriptor) { printf("%s - begin\n", __func__); disp_ErrorCode(ErrorDescriptor.errorCode); if(ErrorDescriptor.errorText != NULL) { disp_ErrorText(*ErrorDescriptor.errorText); } printf("%s - end\n", __func__); return; } /* ErrorCode ::= INTEGER(0..65535) */ /* -- See section 13 for IANA considerations w.r.t. error codes */ void disp_ErrorCode(ErrorCode__t ErrorCode) { printf("%s - begin\n", __func__); printf("%jd\n", ErrorCode); printf("%s - end\n", __func__); return; } /* ErrorText ::= IA5String */ void disp_ErrorText(ErrorText__t ErrorText) { printf("%s - begin\n", __func__); disp_IA5String(ErrorText); printf("%s - end\n", __func__); return; } /* ContextID ::= INTEGER(0..4294967295) */ /* -- Context NULL Value: 0 */ /* -- Context CHOOSE Value: 4294967294 (0xFFFFFFFE) */ /* -- Context ALL Value: 4294967295 (0xFFFFFFFF) */ void disp_ContextID(ContextID__t ContextID) { printf("%s - begin\n", __func__); printf("%jd\n", ContextID); printf("%s - end\n", __func__); return; } /* ActionRequest ::= SEQUENCE */ /* { */ /* contextId ContextID, */ /* contextRequest ContextRequest OPTIONAL, */ /* contextAttrAuditReq ContextAttrAuditRequest OPTIONAL, */ /* commandRequests SEQUENCE OF CommandRequest */ /* } */ void disp_ActionRequest(ActionRequest__t ActionRequest) { printf("%s - begin\n", __func__); disp_ContextID(ActionRequest.contextId); if(ActionRequest.contextRequest != NULL) { disp_ContextRequest(*ActionRequest.contextRequest); } if(ActionRequest.contextAttrAuditReq != NULL) { disp_ContextAttrAuditRequest(*ActionRequest.contextAttrAuditReq); } printf("CommandRequest * %zd\n", Instances(ActionRequest.commandRequests)); for(size_t i = 1; i <= Instances(ActionRequest.commandRequests); i++) { disp_CommandRequest(ActionRequest.commandRequests[i]); } printf("%s - end\n", __func__); return; } /* ActionReply ::= SEQUENCE */ /* { */ /* contextId ContextID, */ /* errorDescriptor ErrorDescriptor OPTIONAL, */ /* contextReply ContextRequest OPTIONAL, */ /* commandReply SEQUENCE OF CommandReply */ /* } */ void disp_ActionReply(ActionReply__t ActionReply) { printf("%s - begin\n", __func__); disp_ContextID(ActionReply.contextId); if(ActionReply.errorDescriptor != NULL) { disp_ErrorDescriptor(*ActionReply.errorDescriptor); } if(ActionReply.contextReply != NULL) { disp_ContextRequest(*ActionReply.contextReply); } printf("CommandReply * %zd\n", Instances(ActionReply.commandReply)); for(size_t i = 1; i <= Instances(ActionReply.commandReply); i++) { disp_CommandReply(ActionReply.commandReply[i]); } printf("%s - end\n", __func__); return; } /* ContextRequest ::= SEQUENCE */ /* { */ /* priority INTEGER(0..15) OPTIONAL, */ /* emergency BOOLEAN OPTIONAL, */ /* topologyReq SEQUENCE OF TopologyRequest OPTIONAL, */ /* ... */ /* } */ void disp_ContextRequest(ContextRequest__t ContextRequest) { printf("%s - begin\n", __func__); if(ContextRequest.priority != NULL) { printf("priority %jd\n", *ContextRequest.priority); } if(ContextRequest.emergency != NULL) { printf("emergency %d\n", *ContextRequest.emergency); } if(ContextRequest.topologyReq != NULL) { printf("TopologyRequest * %zd\n", Instances(ContextRequest.topologyReq)); for(size_t i = 1; i <= Instances(ContextRequest.topologyReq); i++) { disp_TopologyRequest(ContextRequest.topologyReq[i]); } } printf("%s - end\n", __func__); return; } /* ContextAttrAuditRequest ::= SEQUENCE */ /* { */ /* topology NULL OPTIONAL, */ /* emergency NULL OPTIONAL, */ /* priority NULL OPTIONAL, */ /* ... */ /* } */ void disp_ContextAttrAuditRequest(ContextAttrAuditRequest__t ContextAttrAuditRequest) { printf("%s - begin\n", __func__); if(ContextAttrAuditRequest.topology != NULL) { printf("topology -present-\n"); } if(ContextAttrAuditRequest.emergency != NULL) { printf("emergency -present-\n"); } if(ContextAttrAuditRequest.priority != NULL) { printf("priority -present-\n"); } printf("%s - end\n", __func__); return; } /* CommandRequest ::= SEQUENCE */ /* { */ /* command Command, */ /* optional NULL OPTIONAL, */ /* wildcardReturn NULL OPTIONAL, */ /* ... */ /* } */ void disp_CommandRequest(CommandRequest__t CommandRequest) { printf("%s - begin\n", __func__); disp_Command(CommandRequest.command); if(CommandRequest.optional != NULL) { printf("optional -present-"); } if(CommandRequest.wildcardReturn != NULL) { printf("wildcardReturn -present-"); } printf("%s - end\n", __func__); return; } /* Command ::= CHOICE */ /* { */ /* addReq AmmRequest, */ /* moveReq AmmRequest, */ /* modReq AmmRequest, */ /* -- Add, Move, Modify requests have the same parameters */ /* subtractReq SubtractRequest, */ /* auditCapRequest AuditRequest, */ /* auditValueRequest AuditRequest, */ /* notifyReq NotifyRequest, */ /* serviceChangeReq ServiceChangeRequest, */ /* ... */ /* } */ void disp_Command(Command__t Command) { printf("%s - begin\n", __func__); switch(Alternative(Command)) { case 1: { printf("addReq\n"); disp_AmmRequest(*Command.addReq); break; } case 2: { printf("moveReq\n"); disp_AmmRequest(*Command.moveReq); break; } case 3: { printf("modReq\n"); disp_AmmRequest(*Command.modReq); break; } case 4: { printf("subtractReq\n"); disp_SubtractRequest(*Command.subtractReq); break; } case 5: { printf("auditCapRequest\n"); disp_AuditRequest(*Command.auditCapRequest); break; } case 6: { printf("auditValueRequest\n"); disp_AuditRequest(*Command.auditValueRequest); break; } case 7: { printf("notifyReq\n"); disp_NotifyRequest(*Command.notifyReq); break; } case 8: { printf("serviceChangeReq\n"); disp_ServiceChangeRequest(*Command.serviceChangeReq); break; } default: { printf("Error!!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* CommandReply ::= CHOICE */ /* { */ /* addReply AmmsReply, */ /* moveReply AmmsReply, */ /* modReply AmmsReply, */ /* subtractReply AmmsReply, */ /* -- Add, Move, Modify, Subtract replies have the same parameters */ /* auditCapReply AuditReply, */ /* auditValueReply AuditReply, */ /* notifyReply NotifyReply, */ /* serviceChangeReply ServiceChangeReply, */ /* ... */ /* } */ void disp_CommandReply(CommandReply__t CommandReply) { printf("%s - begin\n", __func__); switch(Alternative(CommandReply)) { case 1: { printf("addReply\n"); disp_AmmsReply(*CommandReply.addReply); break; } case 2: { printf("moveReply\n"); disp_AmmsReply(*CommandReply.moveReply); break; } case 3: { printf("modReply\n"); disp_AmmsReply(*CommandReply.modReply); break; } case 4: { printf("subtractReply\n"); disp_AmmsReply(*CommandReply.subtractReply); break; } case 5: { printf("auditCapReply\n"); disp_AuditReply(*CommandReply.auditCapReply); break; } case 6: { printf("auditValueReply\n"); disp_AuditReply(*CommandReply.auditValueReply); break; } case 7: { printf("notifyReply\n"); disp_NotifyReply(*CommandReply.notifyReply); break; } case 8: { printf("serviceChangeReply\n"); disp_ServiceChangeReply(*CommandReply.serviceChangeReply); break; } default: { printf("Error!!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* TopologyRequest ::= SEQUENCE */ /* { */ /* terminationFrom TerminationID, */ /* terminationTo TerminationID, */ /* topologyDirection ENUMERATED */ /* { */ /* bothway(0), */ /* isolate(1), */ /* oneway(2) */ /* } */ /* } */ void disp_TopologyRequest(TopologyRequest__t TopologyRequest) { printf("%s - begin\n", __func__); disp_TerminationID(TopologyRequest.terminationFrom); disp_TerminationID(TopologyRequest.terminationTo); printf("topologyDirection %d\n", TopologyRequest.topologyDirection); printf("%s - end\n", __func__); return; } /* AmmRequest ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* descriptors SEQUENCE OF AmmDescriptor, */ /* -- At most one descriptor of each type (see AmmDescriptor) */ /* -- allowed in the sequence. */ /* ... */ /* } */ void disp_AmmRequest(AmmRequest__t AmmRequest) { printf("%s - begin\n", __func__); disp_TerminationIDList(AmmRequest.terminationID); printf("AmmDescriptor * %zd\n", Instances(AmmRequest.descriptors)); for(size_t i = 1; i <= Instances(AmmRequest.descriptors); i++) { disp_AmmDescriptor(AmmRequest.descriptors[i]); } printf("%s - end\n", __func__); return; } /* AmmDescriptor ::= CHOICE */ /* { */ /* mediaDescriptor MediaDescriptor, */ /* modemDescriptor ModemDescriptor, */ /* muxDescriptor MuxDescriptor, */ /* eventsDescriptor EventsDescriptor, */ /* eventBufferDescriptor EventBufferDescriptor, */ /* signalsDescriptor SignalsDescriptor, */ /* digitMapDescriptor DigitMapDescriptor, */ /* auditDescriptor AuditDescriptor, */ /* ... */ /* } */ void disp_AmmDescriptor(AmmDescriptor__t AmmDescriptor) { printf("%s - begin\n", __func__); switch(Alternative(AmmDescriptor)) { case 1: { printf("mediaDescriptor\n"); disp_MediaDescriptor(*AmmDescriptor.mediaDescriptor); break; } case 2: { printf("modemDescriptor\n"); disp_ModemDescriptor(*AmmDescriptor.modemDescriptor); break; } case 3: { printf("muxDescriptor\n"); disp_MuxDescriptor(*AmmDescriptor.muxDescriptor); break; } case 4: { printf("eventsDescriptor\n"); disp_EventsDescriptor(*AmmDescriptor.eventsDescriptor); break; } case 5: { printf("eventBufferDescriptor\n"); disp_EventBufferDescriptor(AmmDescriptor.eventBufferDescriptor); break; } case 6: { printf("signalsDescriptor\n"); disp_SignalsDescriptor(AmmDescriptor.signalsDescriptor); break; } case 7: { printf("digitMapDescriptor\n"); disp_DigitMapDescriptor(*AmmDescriptor.digitMapDescriptor); break; } case 8: { printf("auditDescriptor\n"); disp_AuditDescriptor(*AmmDescriptor.auditDescriptor); break; } default: { printf("Error!!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* AmmsReply ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* terminationAudit TerminationAudit OPTIONAL, */ /* ... */ /* } */ void disp_AmmsReply(AmmsReply__t AmmsReply) { printf("%s - begin\n", __func__); disp_TerminationIDList(AmmsReply.terminationID); if(AmmsReply.terminationAudit != NULL) { disp_TerminationAudit(AmmsReply.terminationAudit); } printf("%s - end\n", __func__); return; } /* SubtractRequest ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* auditDescriptor AuditDescriptor OPTIONAL, */ /* ... */ /* } */ void disp_SubtractRequest(SubtractRequest__t SubtractRequest) { printf("%s - begin\n", __func__); disp_TerminationIDList(SubtractRequest.terminationID); if(SubtractRequest.auditDescriptor != NULL) { disp_AuditDescriptor(*SubtractRequest.auditDescriptor); } printf("%s - end\n", __func__); return; } /* AuditRequest ::= SEQUENCE */ /* { */ /* terminationID TerminationID, */ /* auditDescriptor AuditDescriptor, */ /* ... */ /* } */ void disp_AuditRequest(AuditRequest__t AuditRequest) { printf("%s - begin\n", __func__); disp_TerminationID(AuditRequest.terminationID); disp_AuditDescriptor(AuditRequest.auditDescriptor); printf("%s - end\n", __func__); return; } /* AuditReply ::= CHOICE */ /* { */ /* contextAuditResult TerminationIDList, */ /* error ErrorDescriptor, */ /* auditResult AuditResult, */ /* ... */ /* } */ void disp_AuditReply(AuditReply__t AuditReply) { printf("%s - begin\n", __func__); switch(Alternative(AuditReply)) { case 1: { printf("contextAuditResult\n"); disp_TerminationIDList(AuditReply.contextAuditResult); break; } case 2: { printf("error\n"); disp_ErrorDescriptor(*AuditReply.error); break; } case 3: { printf("auditResult\n"); disp_AuditResult(*AuditReply.auditResult); break; } default: { printf("Error!!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* AuditResult ::= SEQUENCE */ /* { */ /* terminationID TerminationID, */ /* terminationAuditResult TerminationAudit */ /* } */ void disp_AuditResult(AuditResult__t AuditResult) { printf("%s - begin\n", __func__); disp_TerminationID(AuditResult.terminationID); disp_TerminationAudit(AuditResult.terminationAuditResult); printf("%s - end\n", __func__); return; } /* TerminationAudit ::= SEQUENCE OF AuditReturnParameter */ void disp_TerminationAudit(TerminationAudit__t TerminationAudit) { printf("%s - begin\n", __func__); printf("AuditReturnParameter * %zd\n", Instances(TerminationAudit)); for(size_t i = 1; i <= Instances(TerminationAudit); i++) { disp_AuditReturnParameter(TerminationAudit[i]); } printf("%s - end\n", __func__); return; } /* AuditReturnParameter ::= CHOICE */ /* { */ /* errorDescriptor ErrorDescriptor, */ /* mediaDescriptor MediaDescriptor, */ /* modemDescriptor ModemDescriptor, */ /* muxDescriptor MuxDescriptor, */ /* eventsDescriptor EventsDescriptor, */ /* eventBufferDescriptor EventBufferDescriptor, */ /* signalsDescriptor SignalsDescriptor, */ /* digitMapDescriptor DigitMapDescriptor, */ /* observedEventsDescriptor ObservedEventsDescriptor, */ /* statisticsDescriptor StatisticsDescriptor, */ /* packagesDescriptor PackagesDescriptor, */ /* emptyDescriptors AuditDescriptor, */ /* ... */ /* } */ void disp_AuditReturnParameter(AuditReturnParameter__t AuditReturnParameter) { printf("%s - begin\n", __func__); switch(Alternative(AuditReturnParameter)) { case 1: { printf("errorDescriptor\n"); disp_ErrorDescriptor(*AuditReturnParameter.errorDescriptor); break; } case 2: { printf("mediaDescriptor\n"); disp_MediaDescriptor(*AuditReturnParameter.mediaDescriptor); break; } case 3: { printf("modemDescriptor\n"); disp_ModemDescriptor(*AuditReturnParameter.modemDescriptor); break; } case 4: { printf("muxDescriptor\n"); disp_MuxDescriptor(*AuditReturnParameter.muxDescriptor); break; } case 5: { printf("eventsDescriptor\n"); disp_EventsDescriptor(*AuditReturnParameter.eventsDescriptor); break; } case 6: { printf("eventBufferDescriptor\n"); disp_EventBufferDescriptor(AuditReturnParameter.eventBufferDescriptor); break; } case 7: { printf("signalsDescriptor\n"); disp_SignalsDescriptor(AuditReturnParameter.signalsDescriptor); break; } case 8: { printf("digitMapDescriptor\n"); disp_DigitMapDescriptor(*AuditReturnParameter.digitMapDescriptor); break; } case 9: { printf("observedEventsDescriptor\n"); disp_ObservedEventsDescriptor(*AuditReturnParameter.observedEventsDescriptor); break; } case 10: { printf("statisticsDescriptor\n"); disp_StatisticsDescriptor(AuditReturnParameter.statisticsDescriptor); break; } case 11: { printf("packagesDescriptor\n"); disp_PackagesDescriptor(AuditReturnParameter.packagesDescriptor); break; } case 12: { printf("emptyDescriptors\n"); disp_AuditDescriptor(*AuditReturnParameter.emptyDescriptors); break; } default: { printf("Error !!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* AuditDescriptor ::= SEQUENCE */ /* { */ /* auditToken BIT STRING */ /* { */ /* muxToken(0), */ /* modemToken(1), */ /* mediaToken(2), */ /* eventsToken(3), */ /* signalsToken(4), */ /* digitMapToken(5), */ /* statsToken(6), */ /* observedEventsToken(7), */ /* packagesToken(8), */ /* eventBufferToken(9) */ /* } OPTIONAL, */ /* ... */ /* } */ void disp_AuditDescriptor(AuditDescriptor__t AuditDescriptor) { printf("%s - begin\n", __func__); if(AuditDescriptor.auditToken != NULL) { disp_BIT_STRING(*AuditDescriptor.auditToken); } printf("%s - end\n", __func__); return; } /* NotifyRequest ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* observedEventsDescriptor ObservedEventsDescriptor, */ /* errorDescriptor ErrorDescriptor OPTIONAL, */ /* ... */ /* } */ void disp_NotifyRequest(NotifyRequest__t NotifyRequest) { printf("%s - begin\n", __func__); disp_TerminationIDList(NotifyRequest.terminationID); disp_ObservedEventsDescriptor(NotifyRequest.observedEventsDescriptor); if(NotifyRequest.errorDescriptor != NULL) { disp_ErrorDescriptor(*NotifyRequest.errorDescriptor); } printf("%s - end\n", __func__); return; } /* NotifyReply ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* errorDescriptor ErrorDescriptor OPTIONAL, */ /* ... */ /* } */ void disp_NotifyReply(NotifyReply__t NotifyReply) { printf("%s - begin\n", __func__); disp_TerminationIDList(NotifyReply.terminationID); if(NotifyReply.errorDescriptor != NULL) { disp_ErrorDescriptor(*NotifyReply.errorDescriptor); } printf("%s - end\n", __func__); return; } /* ObservedEventsDescriptor ::= SEQUENCE */ /* { */ /* requestId RequestID, */ /* observedEventLst SEQUENCE OF ObservedEvent */ /* } */ void disp_ObservedEventsDescriptor(ObservedEventsDescriptor__t ObservedEventsDescriptor) { printf("%s - begin\n", __func__); disp_RequestID(ObservedEventsDescriptor.requestId); printf("ObservedEvent * %zd\n", Instances(ObservedEventsDescriptor.observedEventLst)); for(size_t i = 1; i <= Instances(ObservedEventsDescriptor.observedEventLst); i++) { disp_ObservedEvent(ObservedEventsDescriptor.observedEventLst[i]); } printf("%s - end\n", __func__); return; } /* ObservedEvent ::= SEQUENCE */ /* { */ /* eventName EventName, */ /* streamID StreamID OPTIONAL, */ /* eventParList SEQUENCE OF EventParameter, */ /* timeNotation TimeNotation OPTIONAL, */ /* ... */ /* } */ void disp_ObservedEvent(ObservedEvent__t ObservedEvent) { printf("%s - begin\n", __func__); disp_EventName(ObservedEvent.eventName); if(ObservedEvent.streamID != NULL) { disp_StreamID(*ObservedEvent.streamID); } printf("EventParameter * %zd\n", Instances(ObservedEvent.eventParList)); for(size_t i = 1; i <= Instances(ObservedEvent.eventParList); i++) { disp_EventParameter(ObservedEvent.eventParList[i]); } if(ObservedEvent.timeNotation != NULL) { disp_TimeNotation(*ObservedEvent.timeNotation); } printf("%s - end\n", __func__); return; } /* EventName ::= PkgdName */ void disp_EventName(EventName__t EventName) { printf("%s - begin\n", __func__); disp_PkgdName(EventName); printf("%s - end\n", __func__); return; } /* EventParameter ::= SEQUENCE */ /* { */ /* eventParameterName Name, */ /* value Value, */ /* -- For use of extraInfo see the comment related to propertyParm */ /* extraInfo CHOICE */ /* { */ /* relation Relation, */ /* range BOOLEAN, */ /* sublist BOOLEAN */ /* } OPTIONAL, */ /* ... */ /* } */ void disp_EventParameter(EventParameter__t EventParameter) { printf("%s - begin\n", __func__); disp_Name(EventParameter.eventParameterName); disp_Value(EventParameter.value); if(EventParameter.extraInfo != NULL) { switch(Alternative(*EventParameter.extraInfo)) { case 1: { printf("relation\n"); disp_Relation(*EventParameter.extraInfo->relation); break; } case 2: { printf("range\n"); printf("bool: %d\n", *EventParameter.extraInfo->range); break; } case 3: { printf("sublist\n"); printf("bool: %d\n", *EventParameter.extraInfo->sublist); break; } default: { printf("Error !!! %s\n", __func__); } } } printf("%s - end\n", __func__); return; } /* ServiceChangeRequest ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* serviceChangeParms ServiceChangeParm, */ /* ... */ /* } */ void disp_ServiceChangeRequest(ServiceChangeRequest__t ServiceChangeRequest) { printf("%s - begin\n", __func__); disp_TerminationIDList(ServiceChangeRequest.terminationID); disp_ServiceChangeParm(ServiceChangeRequest.serviceChangeParms); printf("%s - end\n", __func__); return; } /* ServiceChangeReply ::= SEQUENCE */ /* { */ /* terminationID TerminationIDList, */ /* serviceChangeResult ServiceChangeResult, */ /* ... */ /* } */ void disp_ServiceChangeReply(ServiceChangeReply__t ServiceChangeReply) { printf("%s - begin\n", __func__); disp_TerminationIDList(ServiceChangeReply.terminationID); disp_ServiceChangeResult(ServiceChangeReply.serviceChangeResult); printf("%s - end\n", __func__); return; } /* -- For ServiceChangeResult, no parameters are mandatory. Hence the */ /* -- distinction between ServiceChangeParm and ServiceChangeResParm. */ /* ServiceChangeResult ::= CHOICE */ /* { */ /* errorDescriptor ErrorDescriptor, */ /* serviceChangeResParms ServiceChangeResParm */ /* } */ void disp_ServiceChangeResult(ServiceChangeResult__t ServiceChangeResult) { printf("%s - begin\n", __func__); switch(Alternative(ServiceChangeResult)) { case 1: { printf("errorDescriptor\n"); disp_ErrorDescriptor(*ServiceChangeResult.errorDescriptor); break; } case 2: { printf("serviceChangeResParms\n"); disp_ServiceChangeResParm(*ServiceChangeResult.serviceChangeResParms); break; } default: { printf("Error !!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* WildcardField ::= OCTET STRING(SIZE(1)) */ void disp_WildcardField(WildcardField__t WildcardField) { printf("%s - begin\n", __func__); disp_OCTET_STRING(WildcardField); printf("%s - end\n", __func__); return; } /* TerminationID ::= SEQUENCE */ /* { */ /* wildcard SEQUENCE OF WildcardField, */ /* id OCTET STRING(SIZE(1..8)), */ /* ... */ /* } */ /* -- See Section A.1 for explanation of wildcarding mechanism. */ /* -- Termination ID 0xFFFFFFFFFFFFFFFF indicates the ROOT Termination. */ void disp_TerminationID(TerminationID__t TerminationID) { printf("%s - begin\n", __func__); printf("WildcardField * %zd\n", Instances(TerminationID.wildcard)); for(size_t i = 1; i <= Instances(TerminationID.wildcard); i++) { disp_WildcardField(TerminationID.wildcard[i]); } disp_OCTET_STRING(TerminationID.id); printf("%s - end\n", __func__); return; } /* TerminationIDList ::= SEQUENCE OF TerminationID */ void disp_TerminationIDList(TerminationIDList__t TerminationIDList) { printf("%s - begin\n", __func__); printf("TerminationID * %zd\n", Instances(TerminationIDList)); for(size_t i = 1; i <= Instances(TerminationIDList); i++) { disp_TerminationID(TerminationIDList[i]); } printf("%s - end\n", __func__); return; } /* MediaDescriptor ::= SEQUENCE */ /* { */ /* termStateDescr TerminationStateDescriptor OPTIONAL, */ /* streams CHOICE */ /* { */ /* oneStream StreamParms, */ /* multiStream SEQUENCE OF StreamDescriptor */ /* } OPTIONAL, */ /* ... */ /* } */ void disp_MediaDescriptor(MediaDescriptor__t MediaDescriptor) { printf("%s - begin\n", __func__); if(MediaDescriptor.termStateDescr != NULL) { disp_TerminationStateDescriptor(*MediaDescriptor.termStateDescr); } if(MediaDescriptor.streams != NULL) { switch(Alternative(*MediaDescriptor.streams)) { case 1: { printf("oneStream\n"); disp_StreamParms(*MediaDescriptor.streams->oneStream); break; } case 2: { printf("multiStream\n"); printf("StreamDescriptor * %zd\n", Instances(MediaDescriptor.streams->multiStream)); for(size_t i = 1; i <= Instances(MediaDescriptor.streams->multiStream); i++) { disp_StreamDescriptor(MediaDescriptor.streams->multiStream[i]); } break; } default: { printf("Error !!! %s\n", __func__); } } } printf("%s - end\n", __func__); return; } /* StreamDescriptor ::= SEQUENCE */ /* { */ /* streamID StreamID, */ /* streamParms StreamParms */ /* } */ void disp_StreamDescriptor(StreamDescriptor__t StreamDescriptor) { printf("%s - begin\n", __func__); disp_StreamID(StreamDescriptor.streamID); disp_StreamParms(StreamDescriptor.streamParms); printf("%s - end\n", __func__); return; } /* StreamParms ::= SEQUENCE */ /* { */ /* localControlDescriptor LocalControlDescriptor OPTIONAL, */ /* localDescriptor LocalRemoteDescriptor OPTIONAL, */ /* remoteDescriptor LocalRemoteDescriptor OPTIONAL, */ /* ... */ /* } */ void disp_StreamParms(StreamParms__t StreamParms) { printf("%s - begin\n", __func__); if(StreamParms.localControlDescriptor != NULL) { disp_LocalControlDescriptor(*StreamParms.localControlDescriptor); } if(StreamParms.localDescriptor != NULL) { disp_LocalRemoteDescriptor(*StreamParms.localDescriptor); } if(StreamParms.remoteDescriptor != NULL) { disp_LocalRemoteDescriptor(*StreamParms.remoteDescriptor); } printf("%s - end\n", __func__); return; } /* LocalControlDescriptor ::= SEQUENCE */ /* { */ /* streamMode StreamMode OPTIONAL, */ /* reserveValue BOOLEAN OPTIONAL, */ /* reserveGroup BOOLEAN OPTIONAL, */ /* propertyParms SEQUENCE OF PropertyParm, */ /* ... */ /* } */ void disp_LocalControlDescriptor(LocalControlDescriptor__t LocalControlDescriptor) { printf("%s - begin\n", __func__); if(LocalControlDescriptor.streamMode != NULL) { disp_StreamMode(*LocalControlDescriptor.streamMode); } if(LocalControlDescriptor.reserveValue != NULL) { disp_BOOLEAN(*LocalControlDescriptor.reserveValue); } if(LocalControlDescriptor.reserveGroup != NULL) { disp_BOOLEAN(*LocalControlDescriptor.reserveGroup); } printf("PropertyParm * %zd\n", Instances(LocalControlDescriptor.propertyParms)); for(size_t i = 1; i <= Instances(LocalControlDescriptor.propertyParms); i++) { disp_PropertyParm(LocalControlDescriptor.propertyParms[i]); } printf("%s - end\n", __func__); return; } /* StreamMode ::= ENUMERATED */ /* { */ /* sendOnly(0), */ /* recvOnly(1), */ /* sendRecv(2), */ /* inactive(3), */ /* loopBack(4), */ /* ... */ /* } */ void disp_StreamMode(StreamMode__t StreamMode) { printf("%s - begin\n", __func__); disp_ENUMERATED(StreamMode); printf("%s - end\n", __func__); return; } /* -- In PropertyParm, value is a SEQUENCE OF octet string. When sent */ /* -- by an MGC the interpretation is as follows: */ /* -- empty sequence means CHOOSE */ /* -- one element sequence specifies value */ /* -- If the sublist field is not selected, a longer sequence means */ /* -- "choose one of the values" (i.e. value1 OR value2 OR ...) */ /* -- If the sublist field is selected, */ /* -- a sequence with more than one element encodes the value of a */ /* -- list-valued property (i.e. value1 AND value2 AND ...). */ /* -- The relation field may only be selected if the value sequence */ /* -- has length 1. It indicates that the MG has to choose a value */ /* -- for the property. E.g., x > 3 (using the greaterThan */ /* -- value for relation) instructs the MG to choose any value larger */ /* -- than 3 for property x. */ /* -- The range field may only be selected if the value sequence */ /* -- has length 2. It indicates that the MG has to choose a value */ /* -- in the range between the first octet in the value sequence and */ /* -- the trailing octet in the value sequence, including the */ /* -- boundary values. */ /* -- When sent by the MG, only responses to an AuditCapability request */ /* -- may contain multiple values, a range, or a relation field. */ /* PropertyParm ::= SEQUENCE */ /* { */ /* name PkgdName, */ /* value SEQUENCE OF OCTET STRING, */ /* extraInfo CHOICE */ /* { */ /* relation Relation, */ /* range BOOLEAN, */ /* sublist BOOLEAN */ /* } OPTIONAL, */ /* ... */ /* } */ void disp_PropertyParm(PropertyParm__t PropertyParm) { printf("%s - begin\n", __func__); disp_PkgdName(PropertyParm.name); printf("Instances: %d\n", Instances(PropertyParm.value)); for(size_t i = 1; i <= Instances(PropertyParm.value); i++) { disp_OCTET_STRING(PropertyParm.value[i]); } if(PropertyParm.extraInfo != NULL) { switch(Alternative(*PropertyParm.extraInfo)) { case 1: { printf("relation\n"); disp_Relation(*PropertyParm.extraInfo->relation); break; } case 2: { printf("range\n"); disp_BOOLEAN(*PropertyParm.extraInfo->range); break; } case 3: { printf("sublist\n"); disp_BOOLEAN(*PropertyParm.extraInfo->sublist); break; } default: { printf("Error !!! %s\n", __func__); printf("pointer %p\n", PropertyParm.extraInfo); printf("points at value %p\n", *PropertyParm.extraInfo); printf("Alternative: %d", Alternative(*PropertyParm.extraInfo)); } } } printf("%s - end\n", __func__); return; } /* Name ::= OCTET STRING(SIZE(2)) */ void disp_Name(Name__t Name) { printf("%s - begin\n", __func__); disp_OCTET_STRING(Name); printf("%s - end\n", __func__); return; } /* PkgdName ::= OCTET STRING(SIZE(4)) */ /* -- represents Package Name (2 octets) plus Property Name (2 octets) */ /* -- To wildcard a package use 0xFFFF for first two octets, choose */ /* -- is not allowed. To reference native property tag specified in */ /* -- Annex C, use 0x0000 as first two octets. */ /* -- Wildcarding of Package Name is permitted only if Property Name is */ /* -- also wildcarded. */ void disp_PkgdName(PkgdName__t PkgdName) { printf("%s - begin\n", __func__); disp_OCTET_STRING(PkgdName); printf("%s - end\n", __func__); return; } /* Relation ::= ENUMERATED */ /* { */ /* greaterThan(0), */ /* smallerThan(1), */ /* unequalTo(2), */ /* ... */ /* } */ void disp_Relation(Relation__t Relation) { printf("%s - begin\n", __func__); disp_ENUMERATED(Relation); printf("%s - end\n", __func__); return; } /* LocalRemoteDescriptor ::= SEQUENCE */ /* { */ /* propGrps SEQUENCE OF PropertyGroup, */ /* ... */ /* } */ void disp_LocalRemoteDescriptor(LocalRemoteDescriptor__t LocalRemoteDescriptor) { printf("%s - begin\n", __func__); printf("PropertyGroup * %zd\n", Instances(LocalRemoteDescriptor.propGrps)); for(size_t i = 1; i <= Instances(LocalRemoteDescriptor.propGrps); i++) { disp_PropertyGroup(LocalRemoteDescriptor.propGrps[i]); } printf("%s - end\n", __func__); return; } /* PropertyGroup ::= SEQUENCE OF PropertyParm */ void disp_PropertyGroup(PropertyGroup__t PropertyGroup) { printf("%s - begin\n", __func__); printf("PropertyParm * %zd\n", Instances(PropertyGroup)); for(size_t i = 1; i <= Instances(PropertyGroup); i++) { disp_PropertyParm(PropertyGroup[i]); } printf("%s - end\n", __func__); return; } /* TerminationStateDescriptor ::= SEQUENCE */ /* { */ /* propertyParms SEQUENCE OF PropertyParm, */ /* eventBufferControl EventBufferControl OPTIONAL, */ /* serviceState ServiceState OPTIONAL, */ /* ... */ /* } */ void disp_TerminationStateDescriptor(TerminationStateDescriptor__t TerminationStateDescriptor) { printf("%s - begin\n", __func__); printf("PropertyParm * %zd\n", Instances(TerminationStateDescriptor.propertyParms)); for(size_t i = 1; i <= Instances(TerminationStateDescriptor.propertyParms); i++) { disp_PropertyParm(TerminationStateDescriptor.propertyParms[i]); } if(TerminationStateDescriptor.eventBufferControl != NULL) { disp_EventBufferControl(*TerminationStateDescriptor.eventBufferControl); } if(TerminationStateDescriptor.serviceState != NULL) { disp_ServiceState(*TerminationStateDescriptor.serviceState); } printf("%s - end\n", __func__); return; } /* EventBufferControl ::= ENUMERATED */ /* { */ /* off(0), */ /* lockStep(1), */ /* ... */ /* } */ void disp_EventBufferControl(EventBufferControl__t EventBufferControl) { printf("%s - begin\n", __func__); disp_ENUMERATED(EventBufferControl); printf("%s - end\n", __func__); return; } /* ServiceState ::= ENUMERATED */ /* { */ /* test(0), */ /* outOfSvc(1), */ /* inSvc(2), */ /* ... */ /* } */ void disp_ServiceState(ServiceState__t ServiceState) { printf("%s - begin\n", __func__); disp_ENUMERATED(ServiceState); printf("%s - end\n", __func__); return; } /* MuxDescriptor ::= SEQUENCE */ /* { */ /* muxType MuxType, */ /* termList SEQUENCE OF TerminationID, */ /* nonStandardData NonStandardData OPTIONAL, */ /* ... */ /* } */ void disp_MuxDescriptor(MuxDescriptor__t MuxDescriptor) { printf("%s - begin\n", __func__); disp_MuxType(MuxDescriptor.muxType); printf("TerminationID * %zd\n", Instances(MuxDescriptor.termList)); for(size_t i = 1; i <= Instances(MuxDescriptor.termList); i++) { disp_TerminationID(MuxDescriptor.termList[i]); } if(MuxDescriptor.nonStandardData != NULL) { disp_NonStandardData(*MuxDescriptor.nonStandardData); } printf("%s - end\n", __func__); return; } /* MuxType ::= ENUMERATED */ /* { */ /* h221(0), */ /* h223(1), */ /* h226(2), */ /* v76(3), */ /* ... */ /* } */ void disp_MuxType(MuxType__t MuxType) { printf("%s - begin\n", __func__); disp_ENUMERATED(MuxType); printf("%s - end\n", __func__); return; } /* StreamID ::= INTEGER(0..65535) -- 16 bit unsigned integer */ void disp_StreamID(StreamID__t StreamID) { printf("%s - begin\n", __func__); disp_INTEGER(StreamID); printf("%s - end\n", __func__); return; } /* EventsDescriptor ::= SEQUENCE */ /* { */ /* requestID RequestID, */ /* -- IG 6.82 was withdrawn */ /* -- requestID RequestID OPTIONAL, */ /* -- RequestID must be present if eventList is non empty */ /* eventList SEQUENCE OF RequestedEvent, */ /* ... */ /* } */ void disp_EventsDescriptor(EventsDescriptor__t EventsDescriptor) { printf("%s - begin\n", __func__); disp_RequestID(EventsDescriptor.requestID); printf("RequestedEvent * %zd\n", Instances(EventsDescriptor.eventList)); for(size_t i = 1; i <= Instances(EventsDescriptor.eventList); i++) { disp_RequestedEvent(EventsDescriptor.eventList[i]); } printf("%s - end\n", __func__); return; } /* RequestedEvent ::= SEQUENCE */ /* { */ /* pkgdName PkgdName, */ /* streamID StreamID OPTIONAL, */ /* eventAction RequestedActions OPTIONAL, */ /* evParList SEQUENCE OF EventParameter, */ /* ... */ /* } */ void disp_RequestedEvent(RequestedEvent__t RequestedEvent) { printf("%s - begin\n", __func__); disp_PkgdName(RequestedEvent.pkgdName); if(RequestedEvent.streamID != NULL) { disp_StreamID(*RequestedEvent.streamID); } if(RequestedEvent.eventAction != NULL) { disp_RequestedActions(*RequestedEvent.eventAction); } printf("EventParameter * %zd\n", Instances(RequestedEvent.evParList)); for(size_t i = 1; i <= Instances(RequestedEvent.evParList); i++) { disp_EventParameter(RequestedEvent.evParList[i]); } printf("%s - end\n", __func__); return; } /* RequestedActions ::= SEQUENCE */ /* { */ /* keepActive BOOLEAN OPTIONAL, */ /* eventDM EventDM OPTIONAL, */ /* secondEvent SecondEventsDescriptor OPTIONAL, */ /* signalsDescriptor SignalsDescriptor OPTIONAL, */ /* ... */ /* } */ void disp_RequestedActions(RequestedActions__t RequestedActions) { printf("%s - begin\n", __func__); if(RequestedActions.keepActive != NULL) { disp_BOOLEAN(*RequestedActions.keepActive); } if(RequestedActions.eventDM != NULL) { disp_EventDM(*RequestedActions.eventDM); } if(RequestedActions.secondEvent != NULL) { disp_SecondEventsDescriptor(*RequestedActions.secondEvent); } if(RequestedActions.signalsDescriptor != NULL) { disp_SignalsDescriptor(RequestedActions.signalsDescriptor); } printf("%s - end\n", __func__); return; } /* EventDM ::= CHOICE */ /* { */ /* digitMapName DigitMapName, */ /* digitMapValue DigitMapValue */ /* } */ void disp_EventDM(EventDM__t EventDM) { printf("%s - begin\n", __func__); switch(Alternative(EventDM)) { case 1: { printf("digitMapName\n"); disp_DigitMapName(*EventDM.digitMapName); break; } case 2: { printf("digitMapValue\n"); disp_DigitMapValue(*EventDM.digitMapValue); break; } default: { printf("Error !!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* SecondEventsDescriptor ::= SEQUENCE */ /* { */ /* requestID RequestID, */ /* -- IG 6.82 was withdrawn */ /* -- requestID RequestID OPTIONAL, */ /* -- RequestID must be present if eventList is non empty */ /* eventList SEQUENCE OF SecondRequestedEvent, */ /* ... */ /* } */ void disp_SecondEventsDescriptor(SecondEventsDescriptor__t SecondEventsDescriptor) { printf("%s - begin\n", __func__); disp_RequestID(SecondEventsDescriptor.requestID); printf("SecondRequestedEvent * %zd\n", Instances(SecondEventsDescriptor.eventList)); for(size_t i = 1; i <= Instances(SecondEventsDescriptor.eventList); i++) { disp_SecondRequestedEvent(SecondEventsDescriptor.eventList[i]); } printf("%s - end\n", __func__); return; } /* SecondRequestedEvent ::= SEQUENCE */ /* { */ /* pkgdName PkgdName, */ /* streamID StreamID OPTIONAL, */ /* eventAction SecondRequestedActions OPTIONAL, */ /* evParList SEQUENCE OF EventParameter, */ /* ... */ /* } */ void disp_SecondRequestedEvent(SecondRequestedEvent__t SecondRequestedEvent) { printf("%s - begin\n", __func__); disp_PkgdName(SecondRequestedEvent.pkgdName); if(SecondRequestedEvent.streamID != NULL) { disp_StreamID(*SecondRequestedEvent.streamID); } if(SecondRequestedEvent.eventAction != NULL) { disp_SecondRequestedActions(*SecondRequestedEvent.eventAction); } printf("EventParameter * %zd\n", Instances(SecondRequestedEvent.evParList)); for(size_t i = 1; i <= Instances(SecondRequestedEvent.evParList); i++) { disp_EventParameter(SecondRequestedEvent.evParList[i]); } printf("%s - end\n", __func__); return; } /* SecondRequestedActions ::= SEQUENCE */ /* { */ /* keepActive BOOLEAN OPTIONAL, */ /* eventDM EventDM OPTIONAL, */ /* signalsDescriptor SignalsDescriptor OPTIONAL, */ /* ... */ /* } */ void disp_SecondRequestedActions(SecondRequestedActions__t SecondRequestedActions) { printf("%s - begin\n", __func__); if(SecondRequestedActions.keepActive != NULL) { disp_BOOLEAN(*SecondRequestedActions.keepActive); } if(SecondRequestedActions.eventDM != NULL) { disp_EventDM(*SecondRequestedActions.eventDM); } if(SecondRequestedActions.signalsDescriptor != NULL) { disp_SignalsDescriptor(SecondRequestedActions.signalsDescriptor); } printf("%s - end\n", __func__); return; } /* EventBufferDescriptor ::= SEQUENCE OF EventSpec */ void disp_EventBufferDescriptor(EventBufferDescriptor__t EventBufferDescriptor) { printf("%s - begin\n", __func__); printf("EventSpec * %zd\n", Instances(EventBufferDescriptor)); for(size_t i = 1; i <= Instances(EventBufferDescriptor); i++) { disp_EventSpec(EventBufferDescriptor[i]); } printf("%s - end\n", __func__); return; } /* EventSpec ::= SEQUENCE */ /* { */ /* eventName EventName, */ /* streamID StreamID OPTIONAL, */ /* eventParList SEQUENCE OF EventParameter, */ /* ... */ /* } */ void disp_EventSpec(EventSpec__t EventSpec) { printf("%s - begin\n", __func__); disp_EventName(EventSpec.eventName); if(EventSpec.streamID != NULL) { disp_StreamID(*EventSpec.streamID); } printf("EventParameter * %zd\n", Instances(EventSpec.eventParList)); for(size_t i = 1; i <= Instances(EventSpec.eventParList); i++) { disp_EventParameter(EventSpec.eventParList[i]); } printf("%s - end\n", __func__); return; } /* SignalsDescriptor ::= SEQUENCE OF SignalRequest */ void disp_SignalsDescriptor(SignalsDescriptor__t SignalsDescriptor) { printf("%s - begin\n", __func__); printf("SignalRequest * %zd\n", Instances(SignalsDescriptor)); for(size_t i = 1; i <= Instances(SignalsDescriptor); i++) { disp_SignalRequest(SignalsDescriptor[i]); } printf("%s - end\n", __func__); return; } /* SignalRequest ::= CHOICE */ /* { */ /* signal Signal, */ /* seqSigList SeqSigList, */ /* ... */ /* } */ void disp_SignalRequest(SignalRequest__t SignalRequest) { printf("%s - begin\n", __func__); switch(Alternative(SignalRequest)) { case 1: { printf("signal\n"); disp_Signal(*SignalRequest.signal); break; } case 2: { printf("seqSigList\n"); disp_SeqSigList(*SignalRequest.seqSigList); break; } default: { printf("Error !!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* SeqSigList ::= SEQUENCE */ /* { */ /* id INTEGER(0..65535), */ /* signalList SEQUENCE OF Signal */ /* } */ void disp_SeqSigList(SeqSigList__t SeqSigList) { printf("%s - begin\n", __func__); disp_INTEGER(SeqSigList.id); printf("Signal * %zd\n", Instances(SeqSigList.signalList)); for(size_t i = 1; i <= Instances(SeqSigList.signalList); i++) { disp_Signal(SeqSigList.signalList[i]); } printf("%s - end\n", __func__); return; } /* Signal ::= SEQUENCE */ /* { */ /* signalName SignalName, */ /* streamID StreamID OPTIONAL, */ /* sigType SignalType OPTIONAL, */ /* duration INTEGER (0..65535) OPTIONAL, */ /* notifyCompletion NotifyCompletion OPTIONAL, */ /* keepActive BOOLEAN OPTIONAL, */ /* sigParList SEQUENCE OF SigParameter, */ /* ... */ /* } */ void disp_Signal(Signal__t Signal) { printf("%s - begin\n", __func__); disp_SignalName(Signal.signalName); if(Signal.streamID != NULL) { disp_StreamID(*Signal.streamID); } if(Signal.sigType != NULL) { disp_SignalType(*Signal.sigType); } if(Signal.duration != NULL) { disp_INTEGER(*Signal.duration); } if(Signal.notifyCompletion != NULL) { disp_NotifyCompletion(*Signal.notifyCompletion); } if(Signal.keepActive != NULL) { disp_BOOLEAN(*Signal.keepActive); } printf("SigParameter * %zd\n", Instances(Signal.sigParList)); for(size_t i = 1; i <= Instances(Signal.sigParList); i++) { disp_SigParameter(Signal.sigParList[i]); } printf("%s - end\n", __func__); return; } /* SignalType ::= ENUMERATED */ /* { */ /* brief(0), */ /* onOff(1), */ /* timeOut(2), */ /* ... */ /* } */ void disp_SignalType(SignalType__t SignalType) { printf("%s - begin\n", __func__); disp_ENUMERATED(SignalType); printf("%s - end\n", __func__); return; } /* SignalName ::= PkgdName */ void disp_SignalName(SignalName__t SignalName) { printf("%s - begin\n", __func__); disp_PkgdName(SignalName); printf("%s - end\n", __func__); return; } /* NotifyCompletion ::= BIT STRING */ /* { */ /* onTimeOut(0), */ /* onInterruptByEvent(1), */ /* onInterruptByNewSignalDescr(2), */ /* otherReason(3) */ /* } */ void disp_NotifyCompletion(NotifyCompletion__t NotifyCompletion) { printf("%s - begin\n", __func__); disp_BIT_STRING(NotifyCompletion); printf("%s - end\n", __func__); return; } /* SigParameter ::= SEQUENCE */ /* { */ /* sigParameterName Name, */ /* value Value, */ /* -- For use of extraInfo see the comment related to propertyParm */ /* extraInfo CHOICE */ /* { */ /* relation Relation, */ /* range BOOLEAN, */ /* sublist BOOLEAN */ /* } OPTIONAL, */ /* ... */ /* } */ void disp_SigParameter(SigParameter__t SigParameter) { printf("%s - begin\n", __func__); disp_Name(SigParameter.sigParameterName); disp_Value(SigParameter.value); if(SigParameter.extraInfo != NULL) { switch(Alternative(*SigParameter.extraInfo)) { case 1: { printf("relation\n"); disp_Relation(*SigParameter.extraInfo->relation); break; } case 2: { printf("range\n"); disp_BOOLEAN(*SigParameter.extraInfo->range); break; } case 3: { printf("sublist\n"); disp_BOOLEAN(*SigParameter.extraInfo->sublist); break; } default: { printf("Error !!! %s\n", __func__); } } } printf("%s - end\n", __func__); return; } /* RequestID ::= INTEGER(0..4294967295) -- 32 bit unsigned integer */ /* -- Request ALL Value: 4294967295 (0xFFFFFFFF) */ void disp_RequestID(RequestID__t RequestID) { printf("%s - begin\n", __func__); disp_INTEGER(RequestID); printf("%s - end\n", __func__); return; } /* ModemDescriptor ::= SEQUENCE */ /* { */ /* mtl SEQUENCE OF ModemType, */ /* mpl SEQUENCE OF PropertyParm, */ /* nonStandardData NonStandardData OPTIONAL */ /* } */ void disp_ModemDescriptor(ModemDescriptor__t ModemDescriptor) { printf("%s - begin\n", __func__); printf("ModemType * %zd\n", Instances(ModemDescriptor.mtl)); for(size_t i = 1; i <= Instances(ModemDescriptor.mtl); i++) { disp_ModemType(ModemDescriptor.mtl[i]); } printf("PropertyParm * %zd\n", Instances(ModemDescriptor.mpl)); for(size_t i = 1; i <= Instances(ModemDescriptor.mpl); i++) { disp_PropertyParm(ModemDescriptor.mpl[i]); } if(ModemDescriptor.nonStandardData != NULL) { disp_NonStandardData(*ModemDescriptor.nonStandardData); } printf("%s - end\n", __func__); return; } /* ModemType ::= ENUMERATED */ /* { */ /* v18(0), */ /* v22(1), */ /* v22bis(2), */ /* v32(3), */ /* v32bis(4), */ /* v34(5), */ /* v90(6), */ /* v91(7), */ /* synchISDN(8), */ /* ... */ /* } */ void disp_ModemType(ModemType__t ModemType) { printf("%s - begin\n", __func__); disp_ENUMERATED(ModemType); printf("%s - end\n", __func__); return; } /* DigitMapDescriptor ::= SEQUENCE */ /* { */ /* digitMapName DigitMapName OPTIONAL, */ /* digitMapValue DigitMapValue OPTIONAL */ /* } */ void disp_DigitMapDescriptor(DigitMapDescriptor__t DigitMapDescriptor) { printf("%s - begin\n", __func__); if(DigitMapDescriptor.digitMapName != NULL) { disp_DigitMapName(*DigitMapDescriptor.digitMapName); } if(DigitMapDescriptor.digitMapValue != NULL) { disp_DigitMapValue(*DigitMapDescriptor.digitMapValue); } printf("%s - end\n", __func__); return; } /* DigitMapName ::= Name */ void disp_DigitMapName(DigitMapName__t DigitMapName) { printf("%s - begin\n", __func__); disp_Name(DigitMapName); printf("%s - end\n", __func__); return; } /* DigitMapValue ::= SEQUENCE */ /* { */ /* startTimer INTEGER(0..99) OPTIONAL, */ /* shortTimer INTEGER(0..99) OPTIONAL, */ /* longTimer INTEGER(0..99) OPTIONAL, */ /* digitMapBody IA5String, */ /* -- See Section A.3 for explanation of digit map syntax */ /* ... */ /* } */ void disp_DigitMapValue(DigitMapValue__t DigitMapValue) { printf("%s - begin\n", __func__); if(DigitMapValue.startTimer != NULL) { disp_INTEGER(*DigitMapValue.startTimer); } if(DigitMapValue.shortTimer != NULL) { disp_INTEGER(*DigitMapValue.shortTimer); } if(DigitMapValue.longTimer != NULL) { disp_INTEGER(*DigitMapValue.longTimer); } disp_IA5String(DigitMapValue.digitMapBody); printf("%s - end\n", __func__); return; } /* ServiceChangeParm ::= SEQUENCE */ /* { */ /* serviceChangeMethod ServiceChangeMethod, */ /* serviceChangeAddress ServiceChangeAddress OPTIONAL, */ /* serviceChangeVersion INTEGER(0..99) OPTIONAL, */ /* serviceChangeProfile ServiceChangeProfile OPTIONAL, */ /* serviceChangeReason Value, */ /* serviceChangeDelay INTEGER(0..4294967295) OPTIONAL, */ /* -- 32 bit unsigned integer */ /* serviceChangeMgcId MId OPTIONAL, */ /* timeStamp TimeNotation OPTIONAL, */ /* nonStandardData NonStandardData OPTIONAL, */ /* ... */ /* } */ void disp_ServiceChangeParm(ServiceChangeParm__t ServiceChangeParm) { printf("%s - begin\n", __func__); disp_ServiceChangeMethod(ServiceChangeParm.serviceChangeMethod); if(ServiceChangeParm.serviceChangeAddress != NULL) { disp_ServiceChangeAddress(*ServiceChangeParm.serviceChangeAddress); } if(ServiceChangeParm.serviceChangeVersion != NULL) { disp_INTEGER(*ServiceChangeParm.serviceChangeVersion); } if(ServiceChangeParm.serviceChangeProfile != NULL) { disp_ServiceChangeProfile(*ServiceChangeParm.serviceChangeProfile); } disp_Value(ServiceChangeParm.serviceChangeReason); if(ServiceChangeParm.serviceChangeDelay != NULL) { disp_INTEGER(*ServiceChangeParm.serviceChangeDelay); } if(ServiceChangeParm.serviceChangeMgcId != NULL) { disp_MId(*ServiceChangeParm.serviceChangeMgcId); } if(ServiceChangeParm.timeStamp != NULL) { disp_TimeNotation(*ServiceChangeParm.timeStamp); } if(ServiceChangeParm.nonStandardData != NULL) { disp_NonStandardData(*ServiceChangeParm.nonStandardData); } printf("%s - end\n", __func__); return; } /* ServiceChangeAddress ::= CHOICE */ /* { */ /* portNumber INTEGER(0..65535), -- TCP/UDP port number */ /* ip4Address IP4Address, */ /* ip6Address IP6Address, */ /* domainName DomainName, */ /* deviceName PathName, */ /* mtpAddress OCTET STRING(SIZE(2..4)), */ /* ... */ /* } */ void disp_ServiceChangeAddress(ServiceChangeAddress__t ServiceChangeAddress) { printf("%s - begin\n", __func__); switch(Alternative(ServiceChangeAddress)) { case 1: { printf("portNumber\n"); disp_INTEGER(*ServiceChangeAddress.portNumber); break; } case 2: { printf("ip4Address\n"); disp_IP4Address(*ServiceChangeAddress.ip4Address); break; } case 3: { printf("ip6Address\n"); disp_IP6Address(*ServiceChangeAddress.ip6Address); break; } case 4: { printf("domainName\n"); disp_DomainName(*ServiceChangeAddress.domainName); break; } case 5: { printf("deviceName\n"); disp_PathName(*ServiceChangeAddress.deviceName); break; } case 6: { printf("mtpAddress\n"); disp_OCTET_STRING(*ServiceChangeAddress.mtpAddress); break; } default: { printf("Error !!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* ServiceChangeResParm ::= SEQUENCE */ /* { */ /* serviceChangeMgcId MId OPTIONAL, */ /* serviceChangeAddress ServiceChangeAddress OPTIONAL, */ /* serviceChangeVersion INTEGER(0..99) OPTIONAL, */ /* serviceChangeProfile ServiceChangeProfile OPTIONAL, */ /* timeStamp TimeNotation OPTIONAL, */ /* ... */ /* } */ void disp_ServiceChangeResParm(ServiceChangeResParm__t ServiceChangeResParm) { printf("%s - begin\n", __func__); if(ServiceChangeResParm.serviceChangeMgcId != NULL) { disp_MId(*ServiceChangeResParm.serviceChangeMgcId); } if(ServiceChangeResParm.serviceChangeAddress != NULL) { disp_ServiceChangeAddress(*ServiceChangeResParm.serviceChangeAddress); } if(ServiceChangeResParm.serviceChangeVersion != NULL) { disp_INTEGER(*ServiceChangeResParm.serviceChangeVersion); } if(ServiceChangeResParm.serviceChangeProfile != NULL) { disp_ServiceChangeProfile(*ServiceChangeResParm.serviceChangeProfile); } if(ServiceChangeResParm.timeStamp != NULL) { disp_TimeNotation(*ServiceChangeResParm.timeStamp); } printf("%s - end\n", __func__); return; } /* ServiceChangeMethod ::= ENUMERATED */ /* { */ /* failover(0), */ /* forced(1), */ /* graceful(2), */ /* restart(3), */ /* disconnected(4), */ /* handOff(5), */ /* ... */ /* } */ void disp_ServiceChangeMethod(ServiceChangeMethod__t ServiceChangeMethod) { printf("%s - begin\n", __func__); disp_ENUMERATED(ServiceChangeMethod); printf("%s - end\n", __func__); return; } /* ServiceChangeProfile ::= SEQUENCE */ /* { */ /* profileName Name, */ /* version INTEGER(0..99) */ /* } */ void disp_ServiceChangeProfile(ServiceChangeProfile__t ServiceChangeProfile) { printf("%s - begin\n", __func__); disp_Name(ServiceChangeProfile.profileName); disp_INTEGER(ServiceChangeProfile.version); printf("%s - end\n", __func__); return; } /* PackagesDescriptor ::= SEQUENCE OF PackagesItem */ void disp_PackagesDescriptor(PackagesDescriptor__t PackagesDescriptor) { printf("%s - begin\n", __func__); printf("PackagesItem * %zd\n", Instances(PackagesDescriptor)); for(size_t i = 1; i <= Instances(PackagesDescriptor); i++) { disp_PackagesItem(PackagesDescriptor[i]); } printf("%s - end\n", __func__); return; } /* PackagesItem ::= SEQUENCE */ /* { */ /* packageName Name, */ /* packageVersion INTEGER(0..99), */ /* ... */ /* } */ void disp_PackagesItem(PackagesItem__t PackagesItem) { printf("%s - begin\n", __func__); disp_Name(PackagesItem.packageName); disp_INTEGER(PackagesItem.packageVersion); printf("%s - end\n", __func__); return; } /* StatisticsDescriptor ::= SEQUENCE OF StatisticsParameter */ void disp_StatisticsDescriptor(StatisticsDescriptor__t StatisticsDescriptor) { printf("%s - begin\n", __func__); printf("StatisticsParameter * %zd\n", Instances(StatisticsDescriptor)); for(size_t i = 1; i <= Instances(StatisticsDescriptor); i++) { disp_StatisticsParameter(StatisticsDescriptor[i]); } printf("%s - end\n", __func__); return; } /* StatisticsParameter ::= SEQUENCE */ /* { */ /* statName PkgdName, */ /* statValue Value OPTIONAL */ /* } */ void disp_StatisticsParameter(StatisticsParameter__t StatisticsParameter) { printf("%s - begin\n", __func__); disp_PkgdName(StatisticsParameter.statName); if(StatisticsParameter.statValue != NULL) { disp_Value(StatisticsParameter.statValue); } printf("%s - end\n", __func__); return; } /* NonStandardData ::= SEQUENCE */ /* { */ /* nonStandardIdentifier NonStandardIdentifier, */ /* data OCTET STRING */ /* } */ void disp_NonStandardData(NonStandardData__t NonStandardData) { printf("%s - begin\n", __func__); disp_NonStandardIdentifier(NonStandardData.nonStandardIdentifier); disp_OCTET_STRING(NonStandardData.data); printf("%s - end\n", __func__); return; } /* NonStandardIdentifier ::= CHOICE */ /* { */ /* object OBJECT IDENTIFIER, */ /* h221NonStandard H221NonStandard, */ /* experimental IA5String(SIZE(8)), */ /* -- first two characters should be "X-" or "X+" */ /* ... */ /* } */ void disp_NonStandardIdentifier(NonStandardIdentifier__t NonStandardIdentifier) { printf("%s - begin\n", __func__); switch(Alternative(NonStandardIdentifier)) { case 1: { printf("object\n"); disp_OBJECT_IDENTIFIER(*NonStandardIdentifier.object); break; } case 2: { printf("h221NonStandard\n"); disp_H221NonStandard(*NonStandardIdentifier.h221NonStandard); break; } case 3: { printf("experimental\n"); disp_IA5String(*NonStandardIdentifier.experimental); break; } default: { printf("Error !!! %s\n", __func__); } } printf("%s - end\n", __func__); return; } /* H221NonStandard ::= SEQUENCE */ /* { */ /* t35CountryCode1 INTEGER(0..255), */ /* t35CountryCode2 INTEGER(0..255), -- country, as per T.35 */ /* t35Extension INTEGER(0..255), -- assigned nationally */ /* manufacturerCode INTEGER(0..65535), -- assigned nationally */ /* ... */ /* } */ void disp_H221NonStandard(H221NonStandard__t H221NonStandard) { printf("%s - begin\n", __func__); disp_INTEGER(H221NonStandard.t35CountryCode1); disp_INTEGER(H221NonStandard.t35CountryCode2); disp_INTEGER(H221NonStandard.t35Extension); disp_INTEGER(H221NonStandard.manufacturerCode); printf("%s - end\n", __func__); return; } /* TimeNotation ::= SEQUENCE */ /* { */ /* date IA5String(SIZE(8)), -- yyyymmdd format */ /* time IA5String(SIZE(8)) -- hhmmssss format */ /* } */ void disp_TimeNotation(TimeNotation__t TimeNotation) { printf("%s - begin\n", __func__); disp_IA5String(TimeNotation.date); disp_IA5String(TimeNotation.time); printf("%s - end\n", __func__); return; } /* Value ::= SEQUENCE OF OCTET STRING */ void disp_Value(Value__t Value) { printf("%s - begin\n", __func__); printf("OCTET STRING * %zd\n", Instances(Value)); for(size_t i = 1; i <= Instances(Value); i++) { disp_OCTET_STRING(Value[i]); } printf("%s - end\n", __func__); return; } /* END */