← Back to branch summary

~ubuntu-branches/ubuntu/wily/freerdp/wily-proposed

« back to all changes in this revision

Viewing changes to asn1/per_decoder.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt, Jeremy Bicha, Jean-Louis Dupond, Martin Pitt
  • Date: 2012-01-31 10:02:14 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120131100214-jaok3uwvni7sqxth
Tags: 1.0.0-0git1
http://bugs.debian.org/647498
Upload current Debian packaging git to get this rolling for precise.

[ Jeremy Bicha ]
* New upstream release. Closes: #647498.
* Updated symbols and bumped soname
* debian/control:
  - Added new build dependencies
  - Bump Standards-Version to 3.9.2
* debian/source/format: Set to 3.0 (quilt)
* debian/rules: Turn on strict symbols checking
* debian/watch: Watch github

[ Jean-Louis Dupond ]
* debian/control: Updated homepage
* debian/copyright: Reflect upstream switch to the Apache license

[ Martin Pitt ]
* debian/libfreerdp0.symbols: Fix version number, should
  be 1.0~beta5, not 1.0-beta5.
* debian/control: Add libavcodec-dev build dependency, upstream build system
  checks for that. Thanks Jean-Louis Dupond!

Show diffs side-by-side

added added

removed removed

Lines of Context:
asn1/per_decoder.c
1
 
#include <asn_application.h>
2
 
#include <asn_internal.h>
3
 
#include <per_decoder.h>
4
 
 
5
 
/*
6
 
 * Decode a "Production of a complete encoding", X.691#10.1.
7
 
 * The complete encoding contains at least one byte, and is an integral
8
 
 * multiple of 8 bytes.
9
 
 */
10
 
asn_dec_rval_t
11
 
uper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size) {
12
 
        asn_dec_rval_t rval;
13
 
 
14
 
        rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
15
 
        if(rval.consumed) {
16
 
                /*
17
 
                 * We've always given 8-aligned data,
18
 
                 * so convert bits to integral bytes.
19
 
                 */
20
 
                rval.consumed += 7;
21
 
                rval.consumed >>= 3;
22
 
        } else if(rval.code == RC_OK) {
23
 
                if(size) {
24
 
                        if(((uint8_t *)buffer)[0] == 0) {
25
 
                                rval.consumed = 1;      /* 1 byte */
26
 
                        } else {
27
 
                                ASN_DEBUG("Expecting single zeroed byte");
28
 
                                rval.code = RC_FAIL;
29
 
                        }
30
 
                } else {
31
 
                        /* Must contain at least 8 bits. */
32
 
                        rval.code = RC_WMORE;
33
 
                }
34
 
        }
35
 
 
36
 
        return rval;
37
 
}
38
 
 
39
 
asn_dec_rval_t
40
 
uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size, int skip_bits, int unused_bits) {
41
 
        asn_codec_ctx_t s_codec_ctx;
42
 
        asn_dec_rval_t rval;
43
 
        asn_per_data_t pd;
44
 
 
45
 
        if(skip_bits < 0 || skip_bits > 7
46
 
        || unused_bits < 0 || unused_bits > 7
47
 
        || (unused_bits > 0 && !size))
48
 
                _ASN_DECODE_FAILED;
49
 
 
50
 
        /*
51
 
         * Stack checker requires that the codec context
52
 
         * must be allocated on the stack.
53
 
         */
54
 
        if(opt_codec_ctx) {
55
 
                if(opt_codec_ctx->max_stack_size) {
56
 
                        s_codec_ctx = *opt_codec_ctx;
57
 
                        opt_codec_ctx = &s_codec_ctx;
58
 
                }
59
 
        } else {
60
 
                /* If context is not given, be security-conscious anyway */
61
 
                memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
62
 
                s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
63
 
                opt_codec_ctx = &s_codec_ctx;
64
 
        }
65
 
 
66
 
        /* Fill in the position indicator */
67
 
        memset(&pd, 0, sizeof(pd));
68
 
        pd.buffer = (const uint8_t *)buffer;
69
 
        pd.nboff = skip_bits;
70
 
        pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */
71
 
        if(pd.nboff > pd.nbits)
72
 
                _ASN_DECODE_FAILED;
73
 
 
74
 
        /*
75
 
         * Invoke type-specific decoder.
76
 
         */
77
 
        if(!td->uper_decoder)
78
 
                _ASN_DECODE_FAILED;     /* PER is not compiled in */
79
 
        rval = td->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd);
80
 
        if(rval.code == RC_OK) {
81
 
                /* Return the number of consumed bits */
82
 
                rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)
83
 
                                        + pd.nboff - skip_bits;
84
 
                ASN_DEBUG("PER decoding consumed %d, counted %d",
85
 
                        rval.consumed, pd.moved);
86
 
                assert(rval.consumed == pd.moved);
87
 
        } else {
88
 
                /* PER codec is not a restartable */
89
 
                rval.consumed = 0;
90
 
        }
91
 
        return rval;
92
 
}
93