static int
encode_NegTokenResp(unsigned char *p, size_t len, const NegTokenResp * data, size_t * size)
{
size_t ret = 0;
size_t l;
int e;
if ((data)->mechListMIC) {
size_t oldret = ret;
ret = 0;
e = encode_octet_string(p, len, (data)->mechListMIC, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
BACK;
ret += oldret;
}
if ((data)->responseToken) {
size_t oldret = ret;
ret = 0;
e = encode_octet_string(p, len, (data)->responseToken, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
if ((data)->supportedMech) {
size_t oldret = ret;
ret = 0;
e = encode_MechType(p, len, (data)->supportedMech, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
if ((data)->negState) {
size_t oldret = ret;
ret = 0;
e = encode_enumerated(p, len, (data)->negState, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}
int encode_lcs_client_identity(LcsClientIdentity *lcsclientidentity, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int encode_result;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, LCS_CLIENT_IDENTITY_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_lcs_client_identity_xml(lcsclientidentity, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded ++;
if ((encode_result = encode_octet_string(&lcsclientidentity->lcsclientidentityvalue, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
int
encode_ms_network_capability (
MsNetworkCapability * msnetworkcapability,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int encode_result;
/*
* Checking IEI and pointer
*/
CHECK_PDU_POINTER_AND_LENGTH_ENCODER (buffer, MS_NETWORK_CAPABILITY_MINIMUM_LENGTH, len);
#if NAS_DEBUG
dump_ms_network_capability_xml (msnetworkcapability, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded++;
if ((encode_result = encode_octet_string (&msnetworkcapability->msnetworkcapabilityvalue, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
int encode_esm_message_container(EsmMessageContainer *esmmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int32_t encode_result;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, ESM_MESSAGE_CONTAINER_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_esm_message_container_xml(esmmessagecontainer, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
//encoded += 2;
//if ((encode_result = encode_octet_string(&esmmessagecontainer->esmmessagecontainercontents, buffer + sizeof(uint16_t), len - sizeof(uint16_t))) < 0)
if ((encode_result = encode_octet_string(&esmmessagecontainer->esmmessagecontainercontents, lenPtr + sizeof(uint16_t), len - sizeof(uint16_t))) < 0)
return encode_result;
else
encoded += encode_result;
ENCODE_U16(lenPtr, encode_result, encoded);
#if 0
lenPtr[1] = (((encoded - 2 - ((iei > 0) ? 1: 0))) & 0x0000ff00) >> 8;
lenPtr[0] = ((encoded - 2 - ((iei > 0) ? 1: 0))) & 0x000000ff;
#endif
return encoded;
}
int
encode_p_tmsi_signature (
PTmsiSignature * ptmsisignature,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
uint32_t encode_result;
uint32_t encoded = 0;
/*
* Checking IEI and pointer
*/
CHECK_PDU_POINTER_AND_LENGTH_ENCODER (buffer, P_TMSI_SIGNATURE_MINIMUM_LENGTH, len);
#if NAS_DEBUG
dump_p_tmsi_signature_xml (ptmsisignature, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
if ((encode_result = encode_octet_string (&ptmsisignature->ptmsisignaturevalue, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
return encoded;
}
int
encode_TransitedEncoding(unsigned char *p, size_t len, const TransitedEncoding *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;
i = 0;
{
int oldret = ret;
ret = 0;
e = encode_octet_string(p, len, &(data)->contents, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, &(data)->tr_type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}
int encode_nas_message_container(NasMessageContainer *nasmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int encode_result;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, NAS_MESSAGE_CONTAINER_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_nas_message_container_xml(nasmessagecontainer, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded ++;
if ((encode_result = encode_octet_string(&nasmessagecontainer->nasmessagecontainercontents, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
int encode_authentication_failure_parameter(AuthenticationFailureParameter *authenticationfailureparameter, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int encode_result;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, AUTHENTICATION_FAILURE_PARAMETER_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_authentication_failure_parameter_xml(authenticationfailureparameter, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded ++;
if ((encode_result = encode_octet_string(&authenticationfailureparameter->auts, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
int encode_pdn_address(PdnAddress *pdnaddress, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int encode_result;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, PDN_ADDRESS_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_pdn_address_xml(pdnaddress, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded ++;
*(buffer + encoded) = 0x00 |
(pdnaddress->pdntypevalue & 0x7);
encoded++;
if ((encode_result = encode_octet_string(&pdnaddress->pdnaddressinformation, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
int
encode_PA_DATA(unsigned char *p, size_t len, const PA_DATA *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;
i = 0;
{
int oldret = ret;
ret = 0;
e = encode_octet_string(p, len, &(data)->padata_value, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_PADATA_TYPE(p, len, &(data)->padata_type, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}
int
encode_authentication_parameter_autn (
AuthenticationParameterAutn * authenticationparameterautn,
uint8_t iei,
uint8_t * buffer,
uint32_t len)
{
uint8_t *lenPtr;
int encode_result;
uint32_t encoded = 0;
/*
* Checking IEI and pointer
*/
CHECK_PDU_POINTER_AND_LENGTH_ENCODER (buffer, AUTHENTICATION_PARAMETER_AUTN_MINIMUM_LENGTH, len);
#if NAS_DEBUG
dump_authentication_parameter_autn_xml (authenticationparameterautn, iei);
#endif
if (iei > 0) {
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded++;
if ((encode_result = encode_octet_string (&authenticationparameterautn->autn, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
static int
encode_NegTokenInit(unsigned char *p, size_t len, const NegTokenInit * data, size_t * size)
{
size_t ret = 0;
size_t l;
int e;
if ((data)->mechListMIC) {
size_t oldret = ret;
ret = 0;
e = encode_octet_string(p, len, (data)->mechListMIC, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
BACK;
ret += oldret;
}
if ((data)->mechToken) {
size_t oldret = ret;
ret = 0;
e = encode_octet_string(p, len, (data)->mechToken, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
if ((data)->reqFlags) {
size_t oldret = ret;
ret = 0;
e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
} {
size_t oldret = ret;
ret = 0;
e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
BACK;
e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}
int encode_authentication_parameter_rand(AuthenticationParameterRand *authenticationparameterrand, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint32_t encode_result;
uint32_t encoded = 0;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, AUTHENTICATION_PARAMETER_RAND_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_authentication_parameter_rand_xml(authenticationparameterrand, iei);
#endif
if (iei > 0)
{
*buffer = iei;
encoded++;
}
if ((encode_result = encode_octet_string(&authenticationparameterrand->rand, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
return encoded;
}
int
encode_EncryptedData(unsigned char *p, size_t len, const EncryptedData *data, size_t *size)
{
size_t ret = 0;
size_t l;
int i, e;
i = 0;
{
int oldret = ret;
ret = 0;
e = encode_octet_string(p, len, &(data)->cipher, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
BACK;
ret += oldret;
}
if((data)->kvno)
{
int oldret = ret;
ret = 0;
e = encode_integer(p, len, (data)->kvno, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
BACK;
ret += oldret;
}
{
int oldret = ret;
ret = 0;
e = encode_ENCTYPE(p, len, &(data)->etype, &l);
BACK;
e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
BACK;
ret += oldret;
}
e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
BACK;
*size = ret;
return 0;
}
int encode_cli(Cli *cli, uint8_t iei, uint8_t *buffer, uint32_t len)
{
uint8_t *lenPtr;
uint32_t encoded = 0;
int encode_result;
/* Checking IEI and pointer */
CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, CLI_MINIMUM_LENGTH, len);
#if defined (NAS_DEBUG)
dump_cli_xml(cli, iei);
#endif
if (iei > 0)
{
*buffer = iei;
encoded++;
}
lenPtr = (buffer + encoded);
encoded ++;
if ((encode_result = encode_octet_string(&cli->clivalue, buffer + encoded, len - encoded)) < 0)
return encode_result;
else
encoded += encode_result;
*lenPtr = encoded - 1 - ((iei > 0) ? 1 : 0);
return encoded;
}
/**
* Gets all attributes of MDS Instance as an array of AVA_Type's
*
* \param mds the mds.
* \param count The number of attributes
* \param tot_length The total length of the MDS
* \return Array of AVA_Type with attributes
*/
AVA_Type* mds_get_attributes(MDS *mds, intu16* count, intu16 *tot_length)
{
int i;
*count = 17;
AVA_Type *ava = calloc(*count, sizeof(AVA_Type));
intu16 length;
ByteStreamWriter *stream;
*tot_length += 17 * sizeof(ava[0].attribute_id);
*tot_length += 17 * sizeof(ava[0].attribute_value.length);
length = 4;
ava[0].attribute_id = MDC_ATTR_SYS_TYPE;
stream = byte_stream_writer_instance(length);
encode_type(stream, &mds->system_type);
ava[0].attribute_value.value = stream->buffer;
ava[0].attribute_value.length = length;
// stream buffer lives beyond stream
free(stream);
*tot_length += length;
length = sizeof(intu16) * 2 + mds->system_model.manufacturer.length +
mds->system_model.model_number.length;
ava[1].attribute_id = MDC_ATTR_ID_MODEL;
stream = byte_stream_writer_instance(length);
encode_systemmodel(stream, &mds->system_model);
ava[1].attribute_value.value = stream->buffer;
ava[1].attribute_value.length = length;
free(stream);
*tot_length += length;
// length includes intu16 because it is variable-size
length = sizeof(intu16) + mds->system_id.length;
ava[2].attribute_id = MDC_ATTR_SYS_ID;
stream = byte_stream_writer_instance(length);
encode_octet_string(stream, &mds->system_id);
ava[2].attribute_value.value = stream->buffer;
ava[2].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2;
ava[3].attribute_id = MDC_ATTR_DEV_CONFIG_ID;
stream = byte_stream_writer_instance(length);
encode_configid(stream, &mds->dev_configuration_id);
ava[3].attribute_value.value = stream->buffer;
ava[3].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2 + 2 + mds->attribute_value_map.count * (2 + 2);
ava[4].attribute_id = MDC_ATTR_ATTRIBUTE_VAL_MAP;
stream = byte_stream_writer_instance(length);
encode_attrvalmap(stream, &mds->attribute_value_map);
ava[4].attribute_value.value = stream->buffer;
ava[4].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2 + 2 + mds->production_specification.count * (2 + 2 + 2);
for (i = 0; i < mds->production_specification.count; i++) {
ProdSpecEntry *entry = &mds->production_specification.value[i];
length += entry->prod_spec.length;
}
ava[5].attribute_id = MDC_ATTR_ID_PROD_SPECN;
stream = byte_stream_writer_instance(length);
encode_productionspec(stream, &mds->production_specification);
ava[5].attribute_value.value = stream->buffer;
ava[5].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2 + 2 + 4 + 2 + 2 + 4;
ava[6].attribute_id = MDC_ATTR_MDS_TIME_INFO;
stream = byte_stream_writer_instance(length);
encode_mdstimeinfo(stream, &mds->mds_time_info);
ava[6].attribute_value.value = stream->buffer;
ava[6].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 8;
ava[7].attribute_id = MDC_ATTR_TIME_ABS;
stream = byte_stream_writer_instance(length);
encode_absolutetime(stream, &mds->date_and_time);
ava[7].attribute_value.value = stream->buffer;
ava[7].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 4;
ava[8].attribute_id = MDC_ATTR_TIME_REL;
stream = byte_stream_writer_instance(length);
write_intu32(stream, mds->relative_time);
ava[8].attribute_value.value = stream->buffer;
ava[8].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 8;
ava[9].attribute_id = MDC_ATTR_TIME_REL_HI_RES;
stream = byte_stream_writer_instance(length);
encode_highresrelativetime(stream, &mds->hires_relative_time);
ava[9].attribute_value.value = stream->buffer;
ava[9].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 6;
ava[10].attribute_id = MDC_ATTR_TIME_ABS_ADJUST;
stream = byte_stream_writer_instance(length);
encode_absolutetimeadjust(stream, &mds->date_and_time_adjustment);
ava[10].attribute_value.value = stream->buffer;
ava[10].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2;
ava[11].attribute_id = MDC_ATTR_POWER_STAT;
stream = byte_stream_writer_instance(length);
write_intu16(stream, mds->power_status);
ava[11].attribute_value.value = stream->buffer;
ava[11].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2;
ava[12].attribute_id = MDC_ATTR_VAL_BATT_CHARGE;
stream = byte_stream_writer_instance(length);
write_intu16(stream, mds->battery_level);
ava[12].attribute_value.value = stream->buffer;
ava[12].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 4 + 2;
ava[13].attribute_id = MDC_ATTR_TIME_BATT_REMAIN;
stream = byte_stream_writer_instance(length);
encode_batmeasure(stream, &mds->remaining_battery_time);
ava[13].attribute_value.value = stream->buffer;
ava[13].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2 + 2 + mds->reg_cert_data_list.count * ((1 + 1) + 2);
for (i = 0; i < mds->reg_cert_data_list.count; i++) {
RegCertData *entry = &mds->reg_cert_data_list.value[i];
length += entry->auth_body_data.length;
}
ava[14].attribute_id = MDC_ATTR_REG_CERT_DATA_LIST;
stream = byte_stream_writer_instance(length);
encode_regcertdatalist(stream, &mds->reg_cert_data_list);
ava[14].attribute_value.value = stream->buffer;
ava[14].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 2 + 2 + mds->system_type_spec_list.count * (2 + 2);
ava[15].attribute_id = MDC_ATTR_SYS_TYPE_SPEC_LIST;
stream = byte_stream_writer_instance(length);
encode_typeverlist(stream, &mds->system_type_spec_list);
ava[15].attribute_value.value = stream->buffer;
ava[15].attribute_value.length = length;
free(stream);
*tot_length += length;
length = 4;
ava[16].attribute_id = MDC_ATTR_CONFIRM_TIMEOUT;
stream = byte_stream_writer_instance(length);
write_intu32(stream, mds->confirm_timeout);
ava[16].attribute_value.value = stream->buffer;
ava[16].attribute_value.length = length;
free(stream);
*tot_length += length;
return ava;
}
