From 27f9c4ab4b09258424eadf8e1a4a5a20a57c0869 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Sun, 30 Aug 2015 22:47:18 +0200 Subject: migration of code from ffasn1c to asn1c + asn1tostruct.py --- src/Makefile | 15 ++- src/asn1helpers.c | 34 +++++- src/asn1helpers.h | 33 ++---- src/hnbap_common.c | 133 +++++++++++++++++++++++ src/hnbap_common.h | 142 ++++++++++++++++++++++++ src/hnbap_const.h | 54 ---------- src/hnbgw_hnbap.c | 249 ++++++++++++++++++------------------------- src/regen-common-includes.sh | 2 + 8 files changed, 428 insertions(+), 234 deletions(-) create mode 100644 src/hnbap_common.c create mode 100644 src/hnbap_common.h delete mode 100644 src/hnbap_const.h create mode 100755 src/regen-common-includes.sh (limited to 'src') diff --git a/src/Makefile b/src/Makefile index 298a33c..9bff932 100644 --- a/src/Makefile +++ b/src/Makefile @@ -1,11 +1,20 @@ -LIBFFASN1_DIR=../../../kommerz/sysmocom/git/admin/ffasn1c/libffasn1 +ASN1_ROOT=../asn1/ +ASN1_DIR=$(ASN1_ROOT)/hnbap +ASN1_FILES=HNBAP-CommonDataTypes.asn -CFLAGS=-g -Wall `pkg-config --cflags libosmocore libosmovty libosmogsm` -I$(LIBFFASN1_DIR) +ASN1TOSTRUCT:=$(ASN1_ROOT)/utils/asn1tostruct.py +#ASN1_SRCS:=$(patsubst + +CFLAGS=-g -Wall `pkg-config --cflags libosmocore libosmovty libosmogsm` -I$(ASN1_DIR)/asn1c/ LDFLAGS=`pkg-config --libs libosmocore libosmovty libosmogsm` -lsctp all: hnbgw -hnbgw: hnbgw.o hnbgw_hnbap.o hnbap.o asn1helpers.o $(LIBFFASN1_DIR)/libffasn1.a $(LIBFFASN1_DIR)/libffasn1_runtime_stdc.a +.PHONY: hnbap_encoder.c +hnbap_encoder.c: $(ASN1_DIR)/HNBAP-PDU-Contents.asn + $(ASN1TOSTRUCT) -f $< + +hnbgw: asn1helpers.o hnbap_common.o hnbap_encoder.o hnbap_decoder.o hnbgw.o hnbgw_hnbap.o $(CC) $(LDFLAGS) -o $@ $^ %.o: %.c diff --git a/src/asn1helpers.c b/src/asn1helpers.c index fe886e3..436afa5 100644 --- a/src/asn1helpers.c +++ b/src/asn1helpers.c @@ -1,19 +1,45 @@ #include -#include +#include #include "asn1helpers.h" -int asn1_strncpy(char *out, const ASN1String *in, size_t n) +void asn1_u32_to_bitstring(BIT_STRING_t *bitstr, uint32_t *in) +{ + bitstr->buf = (uint8_t *) in; + bitstr->size = sizeof(uint32_t); + bitstr->bits_unused = 0; +} + + +int asn1_strncpy(char *out, const OCTET_STRING_t *in, size_t n) { size_t cpylen = n; - if (in->len < cpylen) - cpylen = in->len; + if (in->size < cpylen) + cpylen = in->size; strncpy(out, (char *)in->buf, cpylen); out[n-1] = '\0'; return cpylen; } + +uint16_t asn1str_to_u16(const OCTET_STRING_t *in) +{ + OSMO_ASSERT(in && in->size >= sizeof(uint16_t)); + return *(uint16_t *)in->buf; +} + +uint8_t asn1str_to_u8(const OCTET_STRING_t *in) +{ + OSMO_ASSERT(in && in->size >= sizeof(uint8_t)); + return *(uint8_t *)in->buf; +} + +uint32_t asn1bitstr_to_u32(const BIT_STRING_t *in) +{ + OSMO_ASSERT(in && in->size >= sizeof(uint32_t)); + return *(uint32_t *)in->buf; +} diff --git a/src/asn1helpers.h b/src/asn1helpers.h index 3861d13..75b00e2 100644 --- a/src/asn1helpers.h +++ b/src/asn1helpers.h @@ -1,29 +1,12 @@ #pragma once -#include +#include -static inline uint16_t asn1str_to_u16(ASN1String *as) -{ - if (as->len < 2) - return 0; - else - return *(uint16_t *)as->buf; -} +#include "BIT_STRING.h" +#include "OCTET_STRING.h" -static inline uint8_t asn1str_to_u8(ASN1String *as) -{ - if (as->len < 1) - return 0; - else - return *(uint8_t *)as->buf; -} - -static inline uint8_t asn1bitstr_to_u32(ASN1BitString *as) -{ - if (as->len < 25) - return 0; - else - return *(uint32_t *)as->buf; -} - -int asn1_strncpy(char *out, const ASN1String *in, size_t n); +void asn1_u32_to_bitstring(BIT_STRING_t *bitstr, uint32_t *in); +int asn1_strncpy(char *out, const OCTET_STRING_t *in, size_t n); +uint16_t asn1str_to_u16(const OCTET_STRING_t *in); +uint8_t asn1str_to_u8(const OCTET_STRING_t *in); +uint32_t asn1bitstr_to_u32(const BIT_STRING_t *in); diff --git a/src/hnbap_common.c b/src/hnbap_common.c new file mode 100644 index 0000000..bd7a0eb --- /dev/null +++ b/src/hnbap_common.c @@ -0,0 +1,133 @@ +#include + +#include + +#include "HNBAP-PDU.h" +#include "hnbap_common.h" + +int asn_debug = 0; +int asn1_xer_print = 0; + +static struct msgb *hnbap_msgb_alloc(void) +{ + return msgb_alloc(1024, "HNBAP Tx"); +} + +#if 0 +ssize_t s1ap_generate_initiating_message(uint8_t ** buffer, + uint32_t * length, + e_ProcedureCode procedureCode, + Criticality_t criticality, + asn_TYPE_descriptor_t * td, void *sptr) +{ + + HNBAP_PDU_t pdu; + ssize_t encoded; + + memset(&pdu, 0, sizeof(HNBAP_PDU_t)); + + pdu.present = HNBAP_PDU_PR_initiatingMessage; + pdu.choice.initiatingMessage.procedureCode = procedureCode; + pdu.choice.initiatingMessage.criticality = criticality; + ANY_fromType_aper(&pdu.choice.initiatingMessage.value, td, sptr); + + if (asn1_xer_print) + xer_fprint(stdout, &asn_DEF_HNBAP_PDU, (void *)&pdu); + + if ((encoded = + aper_encode_to_new_buffer(&asn_DEF_HNBAP_PDU, 0, &pdu, + (void **)buffer)) < 0) { + return -1; + } + + *length = encoded; + return encoded; +} +#endif + +struct msgb *hnbap_generate_successfull_outcome( + e_ProcedureCode procedureCode, + Criticality_t criticality, + asn_TYPE_descriptor_t * td, + void *sptr) +{ + + HNBAP_PDU_t pdu; + struct msgb *msg = hnbap_msgb_alloc(); + asn_enc_rval_t rval; + + memset(&pdu, 0, sizeof(HNBAP_PDU_t)); + pdu.present = HNBAP_PDU_PR_successfulOutcome; + pdu.choice.successfulOutcome.procedureCode = procedureCode; + pdu.choice.successfulOutcome.criticality = criticality; + ANY_fromType_aper(&pdu.choice.successfulOutcome.value, td, sptr); + + rval = aper_encode_to_buffer(&asn_DEF_HNBAP_PDU, &pdu, + msg->data, msgb_length(msg)); + if (rval.encoded < 0) { + msgb_free(msg); + return NULL; + } + + msgb_put(msg, rval.encoded); + + return msg; +} + +#if 0 +ssize_t s1ap_generate_unsuccessfull_outcome(uint8_t ** buffer, + uint32_t * length, + e_ProcedureCode procedureCode, + Criticality_t criticality, + asn_TYPE_descriptor_t * td, + void *sptr) +{ + + HNBAP_PDU_t pdu; + ssize_t encoded; + + memset(&pdu, 0, sizeof(HNBAP_PDU_t)); + + pdu.present = HNBAP_PDU_PR_unsuccessfulOutcome; + pdu.choice.successfulOutcome.procedureCode = procedureCode; + pdu.choice.successfulOutcome.criticality = criticality; + ANY_fromType_aper(&pdu.choice.successfulOutcome.value, td, sptr); + + if ((encoded = + aper_encode_to_new_buffer(&asn_DEF_HNBAP_PDU, 0, &pdu, + (void **)buffer)) < 0) { + return -1; + } + + *length = encoded; + + return encoded; +} +#endif + +IE_t *hnbap_new_ie(ProtocolIE_ID_t id, + Criticality_t criticality, + asn_TYPE_descriptor_t * type, void *sptr) +{ + + IE_t *buff; + + if ((buff = malloc(sizeof(IE_t))) == NULL) { + // Possible error on malloc + return NULL; + } + memset((void *)buff, 0, sizeof(IE_t)); + + buff->id = id; + buff->criticality = criticality; + + ANY_fromType_aper(&buff->value, type, sptr); + + if (asn1_xer_print) + if (xer_fprint(stdout, &asn_DEF_IE, buff) < 0) { + free(buff); + return NULL; + } + + return buff; +} diff --git a/src/hnbap_common.h b/src/hnbap_common.h new file mode 100644 index 0000000..9b77423 --- /dev/null +++ b/src/hnbap_common.h @@ -0,0 +1,142 @@ +#pragma once + +#include "asn_application.h" + +#include "ANY.h" +#include "Access-stratum-release-indicator.h" +#include "AccessResult.h" +#include "AdditionalNeighbourInfoList.h" +#include "AltitudeAndDirection.h" +#include "BIT_STRING.h" +#include "BackoffTimer.h" +#include "BindingID.h" +#include "CELL-FACHMobilitySupport.h" +#include "CGI.h" +#include "CI.h" +#include "CN-DomainIndicator.h" +#include "CSG-Capability.h" +#include "CSG-ID.h" +#include "CSGMembershipStatus.h" +#include "CSGMembershipUpdate.h" +#include "Cause.h" +#include "CauseMisc.h" +#include "CauseProtocol.h" +#include "CauseRadioNetwork.h" +#include "CauseTransport.h" +#include "CellIdentity.h" +#include "ConfigurationInformation.h" +#include "Context-ID.h" +#include "Criticality.h" +#include "CriticalityDiagnostics-IE-List.h" +#include "CriticalityDiagnostics.h" +#include "ESN.h" +#include "ErrorIndication.h" +#include "GTP-TEI.h" +#include "GeographicalCoordinates.h" +#include "GeographicalLocation.h" +#include "HNB-Cell-Access-Mode.h" +#include "HNB-Cell-Identifier.h" +#include "HNB-GWResponse.h" +#include "HNB-Identity-Info.h" +#include "HNB-Identity.h" +#include "HNB-Location-Information.h" +#include "HNB-RNL-Identity.h" +#include "HNBAP-PDU.h" +#include "HNBCapacity.h" +#include "HNBConfigInfo.h" +#include "HNBConfigTransferRequest.h" +#include "HNBConfigTransferResponse.h" +#include "HNBConfigurationInformationMissing.h" +#include "HNBConfigurationInformationProvided.h" +#include "HNBDe-Register.h" +#include "HNBRegisterAccept.h" +#include "HNBRegisterReject.h" +#include "HNBRegisterRequest.h" +#include "IE-Extensions.h" +#include "IE.h" +#include "IMEI.h" +#include "IMSI.h" +#include "IMSIDS41.h" +#include "IMSIESN.h" +#include "INTEGER.h" +#include "IP-Address.h" +#include "InitiatingMessage.h" +#include "Ipv4Address.h" +#include "Ipv6Address.h" +#include "Iurh-Signalling-TNL-AddressList.h" +#include "LAC.h" +#include "LAI.h" +#include "MacroCellID.h" +#include "MacroCoverageInformation.h" +#include "MuxPortNumber.h" +#include "NativeEnumerated.h" +#include "NativeInteger.h" +#include "NeighbourCellIdentityList.h" +#include "NeighbourIdentity.h" +#include "NeighbourInfoList.h" +#include "NeighbourInfoRequestItem.h" +#include "NeighbourInfoRequestList.h" +#include "OBJECT_IDENTIFIER.h" +#include "OCTET_STRING.h" +#include "PLMNidentity.h" +#include "PSC.h" +#include "PTMSI.h" +#include "PTMSIRAI.h" +#include "Presence.h" +#include "PrivateIE-ID.h" +#include "PrivateMessage.h" +#include "ProcedureCode.h" +#include "ProtocolIE-ID.h" +#include "RAB-ID.h" +#include "RABList.h" +#include "RABListItem.h" +#include "RAC.h" +#include "RAI.h" +#include "RNC-ID.h" +#include "Registration-Cause.h" +#include "RelocationComplete.h" +#include "S-RNTIPrefix.h" +#include "SAC.h" +#include "SuccessfulOutcome.h" +#include "TMSIDS41.h" +#include "TMSILAI.h" +#include "TNLUpdateFailure.h" +#include "TNLUpdateRequest.h" +#include "TNLUpdateResponse.h" +#include "TransportInfo.h" +#include "TransportLayerAddress.h" +#include "TriggeringMessage.h" +#include "Tunnel-Information.h" +#include "TypeOfError.h" +#include "U-RNTI.h" +#include "U-RNTIQueryRequest.h" +#include "U-RNTIQueryResponse.h" +#include "UDP-Port-Number.h" +#include "UE-Capabilities.h" +#include "UE-Identity.h" +#include "UEDe-Register.h" +#include "UERegisterAccept.h" +#include "UERegisterReject.h" +#include "UERegisterRequest.h" +#include "URAIdentity.h" +#include "URAIdentityList.h" +#include "UTRANCellID.h" +#include "UnknownU-RNTIIndication.h" +#include "UnsuccessfulOutcome.h" +#include "Update-cause.h" + +#if (ASN1C_ENVIRONMENT_VERSION < 924) +# error "You are compiling with the wrong version of ASN1C" +#endif + +extern int asn1_xer_print; + +struct msgb *hnbap_generate_successfull_outcome( + e_ProcedureCode procedureCode, + Criticality_t criticality, + asn_TYPE_descriptor_t * td, + void *sptr); + +IE_t *hnbap_new_ie(ProtocolIE_ID_t id, Criticality_t criticality, + asn_TYPE_descriptor_t *type, void *sptr); + diff --git a/src/hnbap_const.h b/src/hnbap_const.h deleted file mode 100644 index 36c5422..0000000 --- a/src/hnbap_const.h +++ /dev/null @@ -1,54 +0,0 @@ -#pragma once - -/* should be auto-generated by ffasn1c, but isn't :( */ -enum hnbap_procedure_code { - HNBAP_PC_HNBRegister = 1, - HNBAP_PC_HNBDe_Register = 2, - HNBAP_PC_UERegister = 3, - HNBAP_PC_UEDe_Register = 4, - HNBAP_PC_ErrorIndication = 5, - HNBAP_PC_privateMessage = 6, - HNBAP_PC_CSGMembershipUpdate = 7, - HNBAP_PC_TNLUpdate = 9, - HNBAP_PC_HNBConfigTransfer = 10, - HNBAP_PC_RelocationComplete = 11, - HNBAP_PC_U_RNTIQuery = 14, -}; - -/* should be auto-generated by ffasn1c, but isn't :( */ -enum hnbap_iei { - HNBAP_IEI_Cause = 1, - HNBAP_IEI_CriticalityDiagnostics = 2, - HNBAP_IEI_HNB_Identity = 3, - HNBAP_IEI_Context_ID = 4, - HNBAP_IEI_UE_Identity = 5, - HNBAP_IEI_LAC = 6, - HNBAP_IEI_RAC = 7, - HNBAP_IEI_HNB_Location_Information = 8, - HNBAP_IEI_PLMNidentity = 9, - HNBAP_IEI_SAC = 10, - HNBAP_IEI_CellIdentity = 11, - HNBAP_IEI_RegistrationCause = 12, - HNBAP_IEI_UE_Capabilities = 13, - HNBAP_IEI_RNC_ID = 14, - HNBAP_IEI_CSG_ID = 15, - HNBAP_IEI_BackoffTimer = 16, - HNBAP_IEI_HNB_Internet_Information = 17, - HNBAP_IEI_HNB_Cell_Acces_Mode = 18, - HNBAP_IEI_MuxPortNumber = 19, - HNBAP_IEI_Service_Area_For_Broadcast = 20, - HNBAP_IEI_CSGMembershipStatus = 21, - HNBAP_IEI_RABList = 22, - HNBAP_IEI_HNBConfigInfo = 23, - HNBAP_IEI_AccessResult = 25, - HNBAP_IEI_Update_cause = 26, - HNBAP_IEI_NeighborInfoList = 27, - HNBAP_IEI_NeighborInfoRequestList = 28, - HNBAP_IEI_Iurh_Signalling_TNL_Address = 29, - HNBAP_IEI_PSC = 30, - HNBAP_IEI_HNB_Cell_Identifier = 31, - HNBAP_IEI_HNB_Tunnel_Information = 41, - HNBAP_IEI_CELL_FACHMobilitySupport = 42, - HNBAP_IEI_S_RNTIPrefix = 43, - /* FIXME */ -}; diff --git a/src/hnbgw_hnbap.c b/src/hnbgw_hnbap.c index 9db670e..5100bf5 100644 --- a/src/hnbgw_hnbap.c +++ b/src/hnbgw_hnbap.c @@ -7,211 +7,164 @@ #include "asn1helpers.h" -#include "hnbap.h" #include "hnbgw.h" -#include "hnbap_const.h" +#include "hnbap_common.h" +#include "hnbap_ies_defs.h" #define IU_MSG_NUM_IES 32 #define IU_MSG_NUM_EXT_IES 32 -/* common structure of a HNBAP / RUA / RANAP message, must have identical - * memory footprint as the other messages, such as HNBRegisterRequest */ -struct iu_common_msg { - ProtocolIE_Container_1 protocolIEs; - BOOL protocolExtensions_option; - ProtocolIE_Container_1 protocolExtensions; -}; - -/* Add an IE to a Iu message - * \param _msg Message to which we want to add - * \param[in] ie Information Element to be added (ffasn1c generated struct) - * \param[in] iei Information Element Identifier - * \param[in] type asn1_type of the IE - * \param[in] ext should this be an extension field? - */ -int iu_msg_add_ie(void *_msg, void *ie, int iei, ASN1CType *type, int ext) +static int hnbgw_hnbap_tx(struct hnb_context *ctx, struct msgb *msg) { - struct iu_common_msg *msg = _msg; - ProtocolIE_Field_1 *field; - - if (ext) { - msg->protocolExtensions_option = TRUE; - if (msg->protocolExtensions.count >= IU_MSG_NUM_EXT_IES) - return -ERANGE; - field = &msg->protocolExtensions.tab[msg->protocolExtensions.count++]; - } else { - if (msg->protocolIEs.count >= IU_MSG_NUM_IES) - return -ERANGE; - field = &msg->protocolIEs.tab[msg->protocolIEs.count++]; - } + /* FIXME */ +} - field->id = iei; - //field->criticality = FIXME; - field->value.type = type; - field->value.u.data = ie; +static int hnbgw_tx_hnb_register_acc(struct hnb_context *ctx) +{ + HNBRegisterAccept_t accept_out; + struct msgb *msg; + int rc; - return 0; -} + /* Single required response IE: RNC-ID */ + HNBRegisterAcceptIEs_t accept = { + .rnc_id = ctx->gw->config.rnc_id + }; + /* encode the Information Elements */ + rc = hnbap_encode_hnbregisteraccepties(&accept_out, &accept); + if (rc < 0) { + return rc; + } + /* generate a successfull outcome PDU */ + msg = hnbap_generate_successful_outcome(ProcedureCode_id_HNBRegister, + Criticality_reject, + &asn_DEF_HNBRegisterAccept, + &accept_out); -static int hnbgw_hnbap_tx(struct HNBAP_PDU *pdu) -{ - /* FIXME */ + return hnbgw_hnbap_tx(ctx, msg); } -static int hnbgw_tx_hnb_register_acc() -{ - /* FIXME */ - /* Single required response IE: RNC-ID */ -} -static int hnbgw_tx_ue_register_acc() +static int hnbgw_tx_ue_register_acc(struct ue_context *ue) { -#if 0 - HNBAP_PDU pdu; - HNBRegisterAccept hnb_reg_acc; - - hnb_reg_acc.protocol_IEs - - pdu.choice = HNBAP_PDU_successfulOutcome; - pdu.u.successfulOutcome.procedureCode = HNBAP_PC_HNBRegister; - pdu.u.successfulOutcome.criticality = ; - pdu.u.successfulOutcome.value.type = asn1_type_HNBRegisterAccept; - pdu.u.successfulOutcome.value.u.data = &hnb_reg_acc; -#endif - /* FIXME */ - /* Single required response IE: RNC-ID */ -} + UERegisterAccept_t accept_out; + UERegisterAcceptIEs_t accept; + struct msgb *msg; + int rc; -/* we type-cast to ProtocolIE_Container_1, as all the containers structs have - * the same definiition. This is of course ugly, but I see no cleaner way. - * Similarly, from the IEI it is clear what the type should be, but in a - * statically typed language we can only return 'void *' and hope the caller - * doesn the right typecast. */ -#define FIND_IE(cont, id) find_ie((const struct ProtocolIE_Container_1 *)cont, id) -static void *find_ie(const struct ProtocolIE_Container_1 *cont, ProtocolIE_ID id) -{ - int i; - - /* iterate over the array of IEs in the IE container and look for the first - * occurrence of the right IEI */ - for (i = 0; i < cont->count; i++) { - ProtocolIE_Field_1 *field = &cont->tab[i]; - if (field->id == id) { - OSMO_ASSERT(field->value.type); - /* FIXME: we shoudl check if it is the correct type, not just any type */ - return field->value.u.data; - } + /* FIXME accept.uE_Identity; */ + asn1_u32_to_bitstring(&accept.context_ID, &ue->context_id); + + rc = hnbap_encode_ueregisteraccepties(&accept_out, &accept); + if (rc < 0) { + return rc; } - return NULL; + + msg = hnbap_generate_successful_outcome(ProcedureCode_id_UERegister, + Criticality_reject, + &asn_DEF_UERegisterAccept, + &accept_out); + return hnbgw_hnbap_tx(ue->hnb, msg); } -static int hnbgw_rx_hnb_register_req(struct hnb_context *ctx, struct HNBRegisterRequest *req) +static int hnbgw_rx_hnb_register_req(struct hnb_context *ctx, ANY_t *in) { - HNB_Identity *identity = - FIND_IE(&req->protocolIEs, HNBAP_IEI_HNB_Identity); - HNB_Location_Information *loc = - FIND_IE(&req->protocolIEs, HNBAP_IEI_HNB_Location_Information); - PLMNidentity *plmn_id = - FIND_IE(&req->protocolIEs, HNBAP_IEI_PLMNidentity); - CellIdentity *cell_id = - FIND_IE(&req->protocolIEs, HNBAP_IEI_CellIdentity); - LAC *lac = FIND_IE(&req->protocolIEs, HNBAP_IEI_LAC); - RAC *rac = FIND_IE(&req->protocolIEs, HNBAP_IEI_RAC); - SAC *sac = FIND_IE(&req->protocolIEs, HNBAP_IEI_SAC); - /* Optional: CSG-ID */ - - if(!identity || !loc || !plmn_id || !cell_id || !lac || !rac || !sac) - return -1; + HNBRegisterRequestIEs_t ies; + int rc; + + rc = hnbap_decode_hnbregisterrequesties(&ies, in); + if (rc < 0) + return rc; /* copy all identity parameters from the message to ctx */ - asn1_strncpy(ctx->identity_info, &identity->hNB_Identity_Info, - sizeof(ctx->identity_info)); - ctx->id.lac = asn1str_to_u16(lac); - ctx->id.sac = asn1str_to_u16(sac); - ctx->id.rac = asn1str_to_u8(rac); - ctx->id.cid = asn1bitstr_to_u32(cell_id); + asn1_strncpy(ctx->identity_info, &ies.hnB_Identity.hNB_Identity_Info, + sizeof(ctx->identity_info)); + ctx->id.lac = asn1str_to_u16(&ies.lac); + ctx->id.sac = asn1str_to_u16(&ies.sac); + ctx->id.rac = asn1str_to_u8(&ies.rac); + ctx->id.cid = asn1bitstr_to_u32(&ies.cellIdentity); //ctx->id.mcc FIXME //ctx->id.mnc FIXME DEBUGP(DMAIN, "HNB-REGISTER-REQ from %s\n", ctx->identity_info); - /* FIXME: Send HNBRegisterAccept */ + /* Send HNBRegisterAccept */ + return hnbgw_tx_hnb_register_acc(ctx); } -static int hnbgw_rx_ue_register_req(struct hnb_context *ctx, struct UERegisterRequest *req) +static int hnbgw_rx_ue_register_req(struct hnb_context *ctx, ANY_t *in) { - UE_Identity *id = - FIND_IE(&req->protocolIEs, HNBAP_IEI_UE_Identity); - Registration_Cause *reg_cause = - FIND_IE(&req->protocolIEs, HNBAP_IEI_RegistrationCause); - UE_Capabilities *ue_cap = - FIND_IE(&req->protocolIEs, HNBAP_IEI_UE_Capabilities); - - if (!id || !reg_cause || !ue_cap) - return -1; + UERegisterRequestIEs_t ies; + struct ue_context *ue; + int rc; - /* FIXME: Send UERegisterAccept */ + rc = hnbap_decode_ueregisterrequesties(&ies, in); + if (rc < 0) + return rc; + + DEBUGP(DMAIN, "UE-REGSITER-REQ ID_type=%d cause=%ld\n", + ies.uE_Identity.present, ies.registration_Cause); + + /* FIXME: convert UE identity into a more palatable format */ + + /* Send UERegisterAccept */ + return hnbgw_tx_ue_register_acc(ue); } -static int hnbgw_rx_initiating_msg(struct hnb_context *hnb, struct InitiatingMessage *imsg) +static int hnbgw_rx_initiating_msg(struct hnb_context *hnb, InitiatingMessage_t *imsg) { int rc; switch (imsg->procedureCode) { - case HNBAP_PC_HNBRegister: /* 8.2 */ - if (imsg->value.type != asn1_type_HNBRegisterRequest) - return -1; - rc = hnbgw_rx_hnb_register_req(hnb, imsg->value.u.data); + case ProcedureCode_id_HNBRegister: /* 8.2 */ + rc = hnbgw_rx_hnb_register_req(hnb, &imsg->value); break; - case HNBAP_PC_HNBDe_Register: /* 8.3 */ + case ProcedureCode_id_HNBDe_Register: /* 8.3 */ break; - case HNBAP_PC_UERegister: /* 8.4 */ - if (imsg->value.type != asn1_type_UERegisterRequest) - return -1; - rc = hnbgw_rx_ue_register_req(hnb, imsg->value.u.data); + case ProcedureCode_id_UERegister: /* 8.4 */ + rc = hnbgw_rx_ue_register_req(hnb, &imsg->value); break; - case HNBAP_PC_UEDe_Register: /* 8.5 */ + case ProcedureCode_id_UEDe_Register: /* 8.5 */ break; - case HNBAP_PC_ErrorIndication: /* 8.6 */ - case HNBAP_PC_TNLUpdate: /* 8.9 */ - case HNBAP_PC_HNBConfigTransfer: /* 8.10 */ - case HNBAP_PC_RelocationComplete: /* 8.11 */ - case HNBAP_PC_U_RNTIQuery: /* 8.12 */ - case HNBAP_PC_privateMessage: + case ProcedureCode_id_ErrorIndication: /* 8.6 */ + case ProcedureCode_id_TNLUpdate: /* 8.9 */ + case ProcedureCode_id_HNBConfigTransfer: /* 8.10 */ + case ProcedureCode_id_RelocationComplete: /* 8.11 */ + case ProcedureCode_id_U_RNTIQuery: /* 8.12 */ + case ProcedureCode_id_privateMessage: break; default: break; } } -static int hnbgw_rx_successful_outcome_msg(struct hnb_context *hnb, struct SuccessfulOutcome *msg) +static int hnbgw_rx_successful_outcome_msg(struct hnb_context *hnb, SuccessfulOutcome_t *msg) { } -static int hnbgw_rx_unsuccessful_outcome_msg(struct hnb_context *hnb, struct UnsuccessfulOutcome *msg) +static int hnbgw_rx_unsuccessful_outcome_msg(struct hnb_context *hnb, UnsuccessfulOutcome_t *msg) { } -static int _hnbgw_hnbap_rx(struct hnb_context *hnb, struct HNBAP_PDU *pdu) +static int _hnbgw_hnbap_rx(struct hnb_context *hnb, HNBAP_PDU_t *pdu) { int rc; /* it's a bit odd that we can't dispatch on procedure code, but * that's not possible */ - switch (pdu->choice) { - case HNBAP_PDU_initiatingMessage: - rc = hnbgw_rx_initiating_msg(hnb, &pdu->u.initiatingMessage); + switch (pdu->present) { + case HNBAP_PDU_PR_initiatingMessage: + rc = hnbgw_rx_initiating_msg(hnb, &pdu->choice.initiatingMessage); break; - case HNBAP_PDU_successfulOutcome: - rc = hnbgw_rx_successful_outcome_msg(hnb, &pdu->u.successfulOutcome); + case HNBAP_PDU_PR_successfulOutcome: + rc = hnbgw_rx_successful_outcome_msg(hnb, &pdu->choice.successfulOutcome); break; - case HNBAP_PDU_unsuccessfulOutcome: - rc = hnbgw_rx_unsuccessful_outcome_msg(hnb, &pdu->u.unsuccessfulOutcome); + case HNBAP_PDU_PR_unsuccessfulOutcome: + rc = hnbgw_rx_unsuccessful_outcome_msg(hnb, &pdu->choice.unsuccessfulOutcome); break; default: return -1; @@ -220,20 +173,20 @@ static int _hnbgw_hnbap_rx(struct hnb_context *hnb, struct HNBAP_PDU *pdu) int hnbgw_hnbap_rx(struct hnb_context *hnb, struct msgb *msg) { - HNBAP_PDU *pdu; - ASN1Error err; + HNBAP_PDU_t _pdu, *pdu = &_pdu; + asn_dec_rval_t dec_ret; int rc; /* decode and handle to _hnbgw_hnbap_rx() */ - rc = asn1_aper_decode(&pdu, asn1_type_HNBAP_PDU, msg->data, msgb_length(msg), &err); - if (rc < 0) { - LOGP(DMAIN, LOGL_ERROR, "Error in ASN.1 decode (bit=%d): %s\n", err.bit_pos, err.msg); + dec_ret = aper_decode(NULL, &asn_DEF_HNBAP_PDU, (void **) &pdu, + msg->data, msgb_length(msg), 0, 0); + if (dec_ret.code != RC_OK) { + LOGP(DMAIN, LOGL_ERROR, "Error in ASN.1 decode\n"); return rc; } rc = _hnbgw_hnbap_rx(hnb, pdu); - asn1_free_value(asn1_type_HNBAP_PDU, pdu); return rc; } diff --git a/src/regen-common-includes.sh b/src/regen-common-includes.sh new file mode 100755 index 0000000..bc029e6 --- /dev/null +++ b/src/regen-common-includes.sh @@ -0,0 +1,2 @@ +#!/bin/sh +for f in `(cd ../asn1/hnbap/asn1c && ls --color=none -1 *.h)`; do echo "#include \"$f\""; done -- cgit v1.2.3