static void
verify(int testNo, T_t *ti) {
asn_enc_rval_t er;
asn_dec_rval_t rv;
unsigned char buf[16];
T_t *to = 0;
fprintf(stderr, "%d IN: { %ld, %ld, %lu, %lu }\n", testNo,
ti->small32range, ti->full32range,
ti->unsigned32, ti->unsplit32);
er = uper_encode_to_buffer(&asn_DEF_T, ti, buf, sizeof buf);
assert(er.encoded == 8 * sizeof(buf));
rv = uper_decode(0, &asn_DEF_T, (void *)&to, buf, sizeof buf, 0, 0);
assert(rv.code == RC_OK);
fprintf(stderr, "%d ENC: %2x%2x%2x%2x %2x%2x%2x%2x\n", testNo,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7]);
fprintf(stderr, "%d OUT: { %ld, %ld, %lu, %lu } vs { %ld, %ld, %lu, %lu }\n",
testNo,
ti->small32range, ti->full32range,
ti->unsigned32, ti->unsplit32,
to->small32range, to->full32range,
to->unsigned32, to->unsplit32);
assert(ti->small32range == to->small32range);
assert(ti->full32range == to->full32range);
assert(ti->unsigned32 == to->unsigned32);
assert(ti->unsplit32 == to->unsplit32);
xer_fprint(stderr, &asn_DEF_T, ti);
xer_fprint(stderr, &asn_DEF_T, to);
}
static void
verify(int testNo, T_t *ti) {
asn_enc_rval_t er;
asn_dec_rval_t rv;
unsigned char buf[2];
T_t *to = 0;
er = uper_encode_to_buffer(&asn_DEF_T, ti, buf, sizeof buf);
fprintf(stderr, "%d IN: %d => %zd\n", testNo, ti->present, er.encoded);
assert(er.encoded >= 1 && er.encoded <= (ssize_t)(8 * sizeof(buf)));
rv = uper_decode(0, &asn_DEF_T, (void *)&to, buf, sizeof buf, 0, 0);
assert(rv.code == RC_OK);
fprintf(stderr, "%d ENC: %2x%2x\n", testNo,
buf[0], buf[1]);
fprintf(stderr, "%d OUT: %d\n", testNo, ti->present);
assert(ti->present == to->present);
if(ti->present == T_PR_second) {
assert(ti->choice.second == to->choice.second);
} else {
assert(ti->choice.first.present == to->choice.first.present);
assert(ti->choice.first.choice.nothing == to->choice.first.choice.nothing);
}
xer_fprint(stderr, &asn_DEF_T, ti);
xer_fprint(stderr, &asn_DEF_T, to);
}
/*
**************************************************************************
* Function: RRLP_DecodeMessage
*
* Parameters:
* [In] uint32_t,
* uint8_t*
* [Out] RRLP_ASN1_pdu_t**
*
* Return value: boolean
*
* Description: Decode the SUPL message from ASN.1
**************************************************************************
*/
boolean RRLP_DecodeMessage(const uint32_t encoded_length, const uint8_t * const encoded_buffer, RRLP_ASN1_pdu_t * *rrlp_message)
{
RRLP_ASN1_pdu_t *decoded_message = NULL;
boolean decoded = FALSE;
asn_codec_ctx_t *opt_codec_ctx = 0;
char *encoded_message;
size_t encoded_message_len;
asn_dec_rval_t rval;
int ecbits = 0; // Extra consumed bits in case of PER
// ASN.1 input messsage
encoded_message = (char *) encoded_buffer;
encoded_message_len = encoded_length;
// Pretend immediate EOF
rval.code = RC_WMORE;
rval.consumed = 0;
rval = uper_decode(opt_codec_ctx, &RRLP_ASN1_PDU, (void **) &decoded_message, encoded_message, encoded_message_len, 0, 0);
ecbits = rval.consumed % 8; // Extra bits
rval.consumed /= 8; // Convert to value in bytes!
if (rval.code == RC_OK) {
*rrlp_message = (RRLP_ASN1_pdu_t *) decoded_message;
decoded = TRUE;
} else {
// RRLP_ERR_("RRLP ASN1 Decoding Error -> %d!\n", rval.code);
}
return (decoded);
}
static void
verify(int testNo, T_t *ti) {
asn_enc_rval_t er;
asn_dec_rval_t rv;
unsigned char buf[20];
T_t *to = 0;
fprintf(stderr, "%d IN: { %lu, %lu, %ld, %ld }\n", testNo,
i2ul(&ti->unsigned33), i2ul(&ti->unsigned42),
i2l(&ti->signed33), i2l(&ti->signed33ext)
);
er = uper_encode_to_buffer(&asn_DEF_T, ti, buf, sizeof buf);
assert(er.encoded >= 33 + 42 + 33 + 1 + 33);
rv = uper_decode(0, &asn_DEF_T, (void *)&to, buf, sizeof buf, 0, 0);
assert(rv.code == RC_OK);
fprintf(stderr, "%d ENC: %2x%2x%2x%2x %2x%2x%2x%2x\n", testNo,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7]);
fprintf(stderr, "%d OUT: { %lu, %lu, %ld, %ld } vs { %lu, %lu, %ld, %ld }\n",
testNo,
i2ul(&ti->unsigned33), i2ul(&ti->unsigned42),
i2l(&ti->signed33), i2l(&ti->signed33ext),
i2ul(&to->unsigned33), i2ul(&to->unsigned42),
i2l(&to->signed33), i2l(&to->signed33ext));
assert(i2ul(&ti->unsigned33) == i2ul(&to->unsigned33));
assert(i2ul(&ti->unsigned42) == i2ul(&to->unsigned42));
assert(i2l(&ti->signed33) == i2l(&to->signed33));
assert(i2l(&ti->signed33ext) == i2l(&to->signed33ext));
xer_fprint(stderr, &asn_DEF_T, ti);
xer_fprint(stderr, &asn_DEF_T, to);
}
/*
**************************************************************************
* Function: SUPL_decode_header
*
* Parameters:
* [In] uint32_t,
* uint8_t*
* [Out] SUPL_ASN1_ulp_hdr_t**
*
* Return value: boolean
*
* Description: Decode the SUPL header from ASN.1
**************************************************************************
*/
boolean SUPL_decode_header(
const uint32_t encoded_length,
const uint8_t * const encoded_buffer,
SUPL_ASN1_ulp_hdr_t * * supl_header)
{
SUPL_ASN1_ulp_hdr_t *decoded_message = NULL;
boolean decoded = FALSE;
asn_codec_ctx_t *opt_codec_ctx = 0;
char *encoded_message;
size_t encoded_message_len;
asn_dec_rval_t rval;
// ASN.1 input messsage
encoded_message = (char*)encoded_buffer;
encoded_message_len = encoded_length;
rval = uper_decode(opt_codec_ctx, &SUPL_ASN1_HDR_ULP_PDU, (void **)&decoded_message, encoded_message, encoded_message_len, 0, 0);
if (rval.code == RC_OK)
{
*supl_header = (SUPL_ASN1_ulp_hdr_t *)decoded_message;
decoded = TRUE;
}
else
{
// SUPL_ERR_("SUPL ASN1 Decoding Error -> %d !\n", rval.code);
}
return (decoded);
}
/*
* Decode a "Production of a complete encoding", X.691#10.1.
* The complete encoding contains at least one byte, and is an integral
* multiple of 8 bytes.
*/
asn_dec_rval_t
uper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size) {
asn_dec_rval_t rval;
rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
if(rval.consumed) {
/*
* We've always given 8-aligned data,
* so convert bits to integral bytes.
*/
rval.consumed += 7;
rval.consumed >>= 3;
} else if(rval.code == RC_OK) {
static PDU_t *
load_object_from(const char *fname, char *fbuf, int size, enum enctype how, int mustfail) {
asn_dec_rval_t rval;
PDU_t *st = 0;
int csize = 1;
if(getenv("INITIAL_CHUNK_SIZE"))
csize = atoi(getenv("INITIAL_CHUNK_SIZE"));
/* Perform multiple iterations with multiple chunks sizes */
for(; csize < 20; csize += 1) {
int fbuf_offset = 0;
int fbuf_left = size;
int fbuf_chunk = csize;
fprintf(stderr, "LOADING OBJECT OF SIZE %d FROM [%s] as %s,"
" chunks %d\n",
size, fname, how==AS_PER?"PER":"XER", csize);
if(st) asn_DEF_PDU.free_struct(&asn_DEF_PDU, st, 0);
st = 0;
do {
fprintf(stderr, "\nDecoding bytes %d..%d (left %d) [%s]\n",
fbuf_offset,
fbuf_chunk < fbuf_left
? fbuf_chunk : fbuf_left,
fbuf_left,
fname);
if(st) {
fprintf(stderr, "=== currently ===\n");
asn_fprint(stderr, &asn_DEF_PDU, st);
fprintf(stderr, "=== end ===\n");
}
switch(how) {
case AS_XER:
rval = xer_decode(0, &asn_DEF_PDU, (void **)&st,
fbuf + fbuf_offset,
fbuf_chunk < fbuf_left
? fbuf_chunk : fbuf_left);
break;
case AS_DER:
assert(0);
break;
case AS_PER:
rval = uper_decode(0, &asn_DEF_PDU,
(void **)&st, fbuf + fbuf_offset,
fbuf_chunk < fbuf_left
? fbuf_chunk : fbuf_left, 0, 0);
if(rval.code == RC_WMORE) {
if(fbuf_chunk == fbuf_left) {
fprintf(stderr, "-> PER decode error (%d bits of %d bytes (c=%d,l=%d)) \n", rval.consumed, size, fbuf_chunk, fbuf_left);
rval.code = RC_FAIL;
rval.consumed += 7;
rval.consumed /= 8;
if(mustfail) {
fprintf(stderr, "-> (this was expected failure)\n");
return 0;
}
} else {
rval.consumed = 0; /* Not restartable */
ASN_STRUCT_FREE(asn_DEF_PDU, st);
st = 0;
fprintf(stderr, "-> PER wants more\n");
}
} else {
fprintf(stderr, "-> PER ret %d/%d mf=%d\n",
rval.code, rval.consumed, mustfail);
/* uper_decode() returns _bits_ */
rval.consumed += 7;
rval.consumed /= 8;
if((mustfail?1:0) == (rval.code == RC_FAIL)) {
if(mustfail) {
fprintf(stderr, "-> (this was expected failure)\n");
return 0;
}
} else {
fprintf(stderr, "-> (unexpected %s)\n", mustfail ? "success" : "failure");
rval.code = RC_FAIL;
}
}
break;
}
fbuf_offset += rval.consumed;
fbuf_left -= rval.consumed;
if(rval.code == RC_WMORE)
fbuf_chunk += 1; /* Give little more */
else
fbuf_chunk = csize; /* Back off */
} while(fbuf_left && rval.code == RC_WMORE);
assert(rval.code == RC_OK);
if(how == AS_PER) {
fprintf(stderr, "[left %d, off %d, size %d]\n",
fbuf_left, fbuf_offset, size);
assert(fbuf_offset == size);
} else {
assert(fbuf_offset - size < 2
|| (fbuf_offset + 1 /* "\n" */ == size
&& fbuf[size - 1] == '\n')
|| (fbuf_offset + 2 /* "\r\n" */ == size
&& fbuf[size - 2] == '\r'
&& fbuf[size - 1] == '\n')
);
}
}
if(st) asn_fprint(stderr, &asn_DEF_PDU, st);
return st;
}
static PDU_t *
load_object_from(const char *fname, enum expectation expectation, char *fbuf, size_t size, enum enctype how) {
asn_dec_rval_t rval;
PDU_t *st = 0;
size_t csize = 1;
if(getenv("INITIAL_CHUNK_SIZE"))
csize = atoi(getenv("INITIAL_CHUNK_SIZE"));
/* Perform multiple iterations with multiple chunks sizes */
for(; csize < 20; csize += 1) {
int fbuf_offset = 0;
int fbuf_left = size;
int fbuf_chunk = csize;
fprintf(stderr, "LOADING OBJECT OF SIZE %zd FROM [%s] as %s,"
" chunks %zd\n",
size, fname, how==AS_PER?"PER":"XER", csize);
if(st) asn_DEF_PDU.free_struct(&asn_DEF_PDU, st, 0);
st = 0;
do {
fprintf(stderr, "Decoding bytes %d..%d (left %d)\n",
fbuf_offset,
fbuf_chunk < fbuf_left
? fbuf_chunk : fbuf_left,
fbuf_left);
if(st) {
fprintf(stderr, "=== currently ===\n");
asn_fprint(stderr, &asn_DEF_PDU, st);
fprintf(stderr, "=== end ===\n");
}
switch(how) {
case AS_XER:
rval = xer_decode(0, &asn_DEF_PDU, (void **)&st,
fbuf + fbuf_offset,
fbuf_chunk < fbuf_left
? fbuf_chunk : fbuf_left);
break;
case AS_PER:
rval = uper_decode(0, &asn_DEF_PDU,
(void **)&st, fbuf + fbuf_offset,
fbuf_chunk < fbuf_left
? fbuf_chunk : fbuf_left, 0, 0);
if(rval.code == RC_WMORE) {
rval.consumed = 0; /* Not restartable */
ASN_STRUCT_FREE(asn_DEF_PDU, st);
st = 0;
fprintf(stderr, "-> PER wants more\n");
} else {
fprintf(stderr, "-> PER ret %d/%ld\n",
rval.code, rval.consumed);
/* uper_decode() returns _bits_ */
rval.consumed += 7;
rval.consumed /= 8;
}
break;
}
fbuf_offset += rval.consumed;
fbuf_left -= rval.consumed;
if(rval.code == RC_WMORE)
fbuf_chunk += 1; /* Give little more */
else
fbuf_chunk = csize; /* Back off */
} while(fbuf_left && rval.code == RC_WMORE);
if(expectation != EXP_BROKEN) {
assert(rval.code == RC_OK);
if(how == AS_PER) {
fprintf(stderr, "[left %d, off %d, size %zd]\n",
fbuf_left, fbuf_offset, size);
assert(fbuf_offset == size);
} else {
assert(fbuf_offset - size < 2
|| (fbuf_offset + 1 /* "\n" */ == size
&& fbuf[size - 1] == '\n')
|| (fbuf_offset + 2 /* "\r\n" */ == size
&& fbuf[size - 2] == '\r'
&& fbuf[size - 1] == '\n')
);
}
} else {
assert(rval.code != RC_OK);
fprintf(stderr, "Failed, but this was expected\n");
asn_DEF_PDU.free_struct(&asn_DEF_PDU, st, 0);
st = 0; /* ignore leak for now */
}
}
if(st) asn_fprint(stderr, &asn_DEF_PDU, st);
return st;
}
