X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/87550f881db0f6583709f7797becb3eef7d5f254..e480573a5ff59ce2ae78793427e61b85dce7eef1:/projects/stargazer/plugins/other/smux/asn1/xer_decoder.c diff --git a/projects/stargazer/plugins/other/smux/asn1/xer_decoder.c b/projects/stargazer/plugins/other/smux/asn1/xer_decoder.c deleted file mode 100644 index 161dc78c..00000000 --- a/projects/stargazer/plugins/other/smux/asn1/xer_decoder.c +++ /dev/null @@ -1,363 +0,0 @@ -/* - * Copyright (c) 2004, 2005 Lev Walkin . All rights reserved. - * Redistribution and modifications are permitted subject to BSD license. - */ -#include -#include -#include /* XER/XML parsing support */ - - -/* - * Decode the XER encoding of a given type. - */ -asn_dec_rval_t -xer_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, - void **struct_ptr, const void *buffer, size_t size) { - asn_codec_ctx_t s_codec_ctx; - - /* - * Stack checker requires that the codec context - * must be allocated on the stack. - */ - if(opt_codec_ctx) { - if(opt_codec_ctx->max_stack_size) { - s_codec_ctx = *opt_codec_ctx; - opt_codec_ctx = &s_codec_ctx; - } - } else { - /* If context is not given, be security-conscious anyway */ - memset(&s_codec_ctx, 0, sizeof(s_codec_ctx)); - s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX; - opt_codec_ctx = &s_codec_ctx; - } - - /* - * Invoke type-specific decoder. - */ - return td->xer_decoder(opt_codec_ctx, td, struct_ptr, 0, buffer, size); -} - - - -struct xer__cb_arg { - pxml_chunk_type_e chunk_type; - size_t chunk_size; - const void *chunk_buf; - int callback_not_invoked; -}; - -static int -xer__token_cb(pxml_chunk_type_e type, const void *_chunk_data, size_t _chunk_size, void *key) { - struct xer__cb_arg *arg = (struct xer__cb_arg *)key; - arg->chunk_type = type; - arg->chunk_size = _chunk_size; - arg->chunk_buf = _chunk_data; - arg->callback_not_invoked = 0; - return -1; /* Terminate the XML parsing */ -} - -/* - * Fetch the next token from the XER/XML stream. - */ -ssize_t -xer_next_token(int *stateContext, const void *buffer, size_t size, pxer_chunk_type_e *ch_type) { - struct xer__cb_arg arg; - int new_stateContext = *stateContext; - ssize_t ret; - - arg.callback_not_invoked = 1; - ret = pxml_parse(&new_stateContext, buffer, size, xer__token_cb, &arg); - if(ret < 0) return -1; - if(arg.callback_not_invoked) { - assert(ret == 0); /* No data was consumed */ - return 0; /* Try again with more data */ - } else { - assert(arg.chunk_size); - assert(arg.chunk_buf == buffer); - } - - /* - * Translate the XML chunk types into more convenient ones. - */ - switch(arg.chunk_type) { - case PXML_TEXT: - *ch_type = PXER_TEXT; - break; - case PXML_TAG: return 0; /* Want more */ - case PXML_TAG_END: - *ch_type = PXER_TAG; - break; - case PXML_COMMENT: - case PXML_COMMENT_END: - *ch_type = PXER_COMMENT; - break; - } - - *stateContext = new_stateContext; - return arg.chunk_size; -} - -#define CSLASH 0x2f /* '/' */ -#define LANGLE 0x3c /* '<' */ -#define RANGLE 0x3e /* '>' */ - -xer_check_tag_e -xer_check_tag(const void *buf_ptr, int size, const char *need_tag) { - const char *buf = (const char *)buf_ptr; - const char *end; - xer_check_tag_e ct = XCT_OPENING; - - if(size < 2 || buf[0] != LANGLE || buf[size-1] != RANGLE) { - if(size >= 2) - ASN_DEBUG("Broken XML tag: \"%c...%c\"", buf[0], buf[size - 1]); - return XCT_BROKEN; - } - - /* - * Determine the tag class. - */ - if(buf[1] == CSLASH) { - buf += 2; /* advance past "" */ - ct = XCT_CLOSING; - if(size > 0 && buf[size-1] == CSLASH) - return XCT_BROKEN; /* */ - } else { - buf++; /* advance past "<" */ - size -= 2; /* strip "<" and ">" */ - if(size > 0 && buf[size-1] == CSLASH) { - ct = XCT_BOTH; - size--; /* One more, for "/" */ - } - } - - /* Sometimes we don't care about the tag */ - if(!need_tag || !*need_tag) - return (xer_check_tag_e)(XCT__UNK__MASK | ct); - - /* - * Determine the tag name. - */ - for(end = buf + size; buf < end; buf++, need_tag++) { - int b = *buf, n = *need_tag; - if(b != n) { - if(n == 0) { - switch(b) { - case 0x09: case 0x0a: case 0x0c: case 0x0d: - case 0x20: - /* "": whitespace is normal */ - return ct; - } - } - return (xer_check_tag_e)(XCT__UNK__MASK | ct); - } - if(b == 0) - return XCT_BROKEN; /* Embedded 0 in buf?! */ - } - if(*need_tag) - return (xer_check_tag_e)(XCT__UNK__MASK | ct); - - return ct; -} - - -#undef ADVANCE -#define ADVANCE(num_bytes) do { \ - size_t num = (num_bytes); \ - buf_ptr = ((const char *)buf_ptr) + num; \ - size -= num; \ - consumed_myself += num; \ - } while(0) - -#undef RETURN -#define RETURN(_code) do { \ - rval.code = _code; \ - rval.consumed = consumed_myself; \ - if(rval.code != RC_OK) \ - ASN_DEBUG("Failed with %d", rval.code); \ - return rval; \ - } while(0) - -#define XER_GOT_BODY(chunk_buf, chunk_size, size) do { \ - ssize_t converted_size = body_receiver \ - (struct_key, chunk_buf, chunk_size, \ - (size_t)chunk_size < size); \ - if(converted_size == -1) RETURN(RC_FAIL); \ - if(converted_size == 0 \ - && size == (size_t)chunk_size) \ - RETURN(RC_WMORE); \ - chunk_size = converted_size; \ - } while(0) -#define XER_GOT_EMPTY() do { \ - if(body_receiver(struct_key, 0, 0, size > 0) == -1) \ - RETURN(RC_FAIL); \ - } while(0) - -/* - * Generalized function for decoding the primitive values. - */ -asn_dec_rval_t -xer_decode_general(asn_codec_ctx_t *opt_codec_ctx, - asn_struct_ctx_t *ctx, /* Type decoder context */ - void *struct_key, - const char *xml_tag, /* Expected XML tag */ - const void *buf_ptr, size_t size, - int (*opt_unexpected_tag_decoder) - (void *struct_key, const void *chunk_buf, size_t chunk_size), - ssize_t (*body_receiver) - (void *struct_key, const void *chunk_buf, size_t chunk_size, - int have_more) - ) { - - asn_dec_rval_t rval; - ssize_t consumed_myself = 0; - - (void)opt_codec_ctx; - - /* - * Phases of XER/XML processing: - * Phase 0: Check that the opening tag matches our expectations. - * Phase 1: Processing body and reacting on closing tag. - */ - if(ctx->phase > 1) RETURN(RC_FAIL); - for(;;) { - pxer_chunk_type_e ch_type; /* XER chunk type */ - ssize_t ch_size; /* Chunk size */ - xer_check_tag_e tcv; /* Tag check value */ - - /* - * Get the next part of the XML stream. - */ - ch_size = xer_next_token(&ctx->context, buf_ptr, size, - &ch_type); - switch(ch_size) { - case -1: RETURN(RC_FAIL); - case 0: - RETURN(RC_WMORE); - default: - switch(ch_type) { - case PXER_COMMENT: /* Got XML comment */ - ADVANCE(ch_size); /* Skip silently */ - continue; - case PXER_TEXT: - if(ctx->phase == 0) { - /* - * We have to ignore whitespace here, - * but in order to be forward compatible - * with EXTENDED-XER (EMBED-VALUES, #25) - * any text is just ignored here. - */ - } else { - XER_GOT_BODY(buf_ptr, ch_size, size); - } - ADVANCE(ch_size); - continue; - case PXER_TAG: - break; /* Check the rest down there */ - } - } - - assert(ch_type == PXER_TAG && size); - - tcv = xer_check_tag(buf_ptr, ch_size, xml_tag); - /* - * Phase 0: - * Expecting the opening tag - * for the type being processed. - * Phase 1: - * Waiting for the closing XML tag. - */ - switch(tcv) { - case XCT_BOTH: - if(ctx->phase) break; - /* Finished decoding of an empty element */ - XER_GOT_EMPTY(); - ADVANCE(ch_size); - ctx->phase = 2; /* Phase out */ - RETURN(RC_OK); - case XCT_OPENING: - if(ctx->phase) break; - ADVANCE(ch_size); - ctx->phase = 1; /* Processing body phase */ - continue; - case XCT_CLOSING: - if(!ctx->phase) break; - ADVANCE(ch_size); - ctx->phase = 2; /* Phase out */ - RETURN(RC_OK); - case XCT_UNKNOWN_BO: - /* - * Certain tags in the body may be expected. - */ - if(opt_unexpected_tag_decoder - && opt_unexpected_tag_decoder(struct_key, - buf_ptr, ch_size) >= 0) { - /* Tag's processed fine */ - ADVANCE(ch_size); - if(!ctx->phase) { - /* We are not expecting - * the closing tag anymore. */ - ctx->phase = 2; /* Phase out */ - RETURN(RC_OK); - } - continue; - } - /* Fall through */ - default: - break; /* Unexpected tag */ - } - - ASN_DEBUG("Unexpected XML tag (expected \"%s\")", xml_tag); - break; /* Dark and mysterious things have just happened */ - } - - RETURN(RC_FAIL); -} - - -int -xer_is_whitespace(const void *chunk_buf, size_t chunk_size) { - const char *p = (const char *)chunk_buf; - const char *pend = p + chunk_size; - - for(; p < pend; p++) { - switch(*p) { - /* X.693, #8.1.4 - * HORISONTAL TAB (9) - * LINE FEED (10) - * CARRIAGE RETURN (13) - * SPACE (32) - */ - case 0x09: case 0x0a: case 0x0d: case 0x20: - break; - default: - return 0; - } - } - return 1; /* All whitespace */ -} - -/* - * This is a vastly simplified, non-validating XML tree skipper. - */ -int -xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth) { - assert(*depth > 0); - switch(tcv) { - case XCT_BOTH: - case XCT_UNKNOWN_BO: - /* These negate each other. */ - return 0; - case XCT_OPENING: - case XCT_UNKNOWN_OP: - ++(*depth); - return 0; - case XCT_CLOSING: - case XCT_UNKNOWN_CL: - if(--(*depth) == 0) - return (tcv == XCT_CLOSING) ? 2 : 1; - return 0; - default: - return -1; - } -}