asn1c_defs/all-defs/per_decoder.c

   1 #include <asn_application.h>\r
   2 #include <asn_internal.h>\r
   3 #include <per_decoder.h>\r
   4 \r
   5 /*\r
   6  * Decode a "Production of a complete encoding", X.691#10.1.\r
   7  * The complete encoding contains at least one byte, and is an integral\r
   8  * multiple of 8 bytes.\r
   9  */\r
  10 asn_dec_rval_t\r
  11 uper_decode_complete(const asn_codec_ctx_t *opt_codec_ctx,\r
  12                      const asn_TYPE_descriptor_t *td, void **sptr,\r
  13                      const void *buffer, size_t size) {\r
  14     asn_dec_rval_t rval;\r
  15 \r
  16         rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);\r
  17         if(rval.consumed) {\r
  18                 /*\r
  19                  * We've always given 8-aligned data,\r
  20                  * so convert bits to integral bytes.\r
  21                  */\r
  22                 rval.consumed += 7;\r
  23                 rval.consumed >>= 3;\r
  24         } else if(rval.code == RC_OK) {\r
  25                 if(size) {\r
  26                         if(((const uint8_t *)buffer)[0] == 0) {\r
  27                                 rval.consumed = 1;      /* 1 byte */\r
  28                         } else {\r
  29                                 ASN_DEBUG("Expecting single zeroed byte");\r
  30                                 rval.code = RC_FAIL;\r
  31                         }\r
  32                 } else {\r
  33                         /* Must contain at least 8 bits. */\r
  34                         rval.code = RC_WMORE;\r
  35                 }\r
  36         }\r
  37 \r
  38         return rval;\r
  39 }\r
  40 \r
  41 asn_dec_rval_t\r
  42 uper_decode(const asn_codec_ctx_t *opt_codec_ctx,\r
  43             const asn_TYPE_descriptor_t *td, void **sptr, const void *buffer,\r
  44             size_t size, int skip_bits, int unused_bits) {\r
  45     asn_codec_ctx_t s_codec_ctx;\r
  46         asn_dec_rval_t rval;\r
  47         asn_per_data_t pd;\r
  48 \r
  49         if(skip_bits < 0 || skip_bits > 7\r
  50         || unused_bits < 0 || unused_bits > 7\r
  51         || (unused_bits > 0 && !size))\r
  52                 ASN__DECODE_FAILED;\r
  53 \r
  54         /*\r
  55          * Stack checker requires that the codec context\r
  56          * must be allocated on the stack.\r
  57          */\r
  58         if(opt_codec_ctx) {\r
  59                 if(opt_codec_ctx->max_stack_size) {\r
  60                         s_codec_ctx = *opt_codec_ctx;\r
  61                         opt_codec_ctx = &s_codec_ctx;\r
  62                 }\r
  63         } else {\r
  64                 /* If context is not given, be security-conscious anyway */\r
  65                 memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));\r
  66                 s_codec_ctx.max_stack_size = ASN__DEFAULT_STACK_MAX;\r
  67                 opt_codec_ctx = &s_codec_ctx;\r
  68         }\r
  69 \r
  70         /* Fill in the position indicator */\r
  71         memset(&pd, 0, sizeof(pd));\r
  72         pd.buffer = (const uint8_t *)buffer;\r
  73         pd.nboff = skip_bits;\r
  74         pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */\r
  75         if(pd.nboff > pd.nbits)\r
  76                 ASN__DECODE_FAILED;\r
  77 \r
  78         /*\r
  79          * Invoke type-specific decoder.\r
  80          */\r
  81         if(!td->op->uper_decoder)\r
  82                 ASN__DECODE_FAILED;     /* PER is not compiled in */\r
  83         rval = td->op->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd);\r
  84         if(rval.code == RC_OK) {\r
  85                 /* Return the number of consumed bits */\r
  86                 rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)\r
  87                                         + pd.nboff - skip_bits;\r
  88                 ASN_DEBUG("PER decoding consumed %ld, counted %ld",\r
  89                         (long)rval.consumed, (long)pd.moved);\r
  90                 assert(rval.consumed == pd.moved);\r
  91         } else {\r
  92                 /* PER codec is not a restartable */\r
  93                 rval.consumed = 0;\r
  94         }\r
  95         return rval;\r
  96 }\r
  97 \r
  98 asn_dec_rval_t\r
  99 aper_decode_complete(const asn_codec_ctx_t *opt_codec_ctx,\r
 100                      const asn_TYPE_descriptor_t *td, void **sptr,\r
 101                      const void *buffer, size_t size) {\r
 102         asn_dec_rval_t rval;\r
 103 \r
 104         rval = aper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);\r
 105         if(rval.consumed) {\r
 106                 /*\r
 107                  * We've always given 8-aligned data,\r
 108                  * so convert bits to integral bytes.\r
 109                  */\r
 110                 rval.consumed += 7;\r
 111                 rval.consumed >>= 3;\r
 112         } else if(rval.code == RC_OK) {\r
 113                 if(size) {\r
 114                         if(((const uint8_t *)buffer)[0] == 0) {\r
 115                                 rval.consumed = 1;      /* 1 byte */\r
 116                         } else {\r
 117                                 ASN_DEBUG("Expecting single zeroed byte");\r
 118                                 rval.code = RC_FAIL;\r
 119                         }\r
 120                 } else {\r
 121                         /* Must contain at least 8 bits. */\r
 122                         rval.code = RC_WMORE;\r
 123                 }\r
 124         }\r
 125 \r
 126         return rval;\r
 127 }\r
 128 \r
 129 asn_dec_rval_t\r
 130 aper_decode(const asn_codec_ctx_t *opt_codec_ctx,\r
 131             const asn_TYPE_descriptor_t *td, void **sptr, const void *buffer,\r
 132             size_t size, int skip_bits, int unused_bits) {\r
 133         asn_codec_ctx_t s_codec_ctx;\r
 134         asn_dec_rval_t rval;\r
 135         asn_per_data_t pd;\r
 136 \r
 137         if(skip_bits < 0 || skip_bits > 7\r
 138                 || unused_bits < 0 || unused_bits > 7\r
 139                 || (unused_bits > 0 && !size))\r
 140                 ASN__DECODE_FAILED;\r
 141 \r
 142         /*\r
 143          * Stack checker requires that the codec context\r
 144          * must be allocated on the stack.\r
 145          */\r
 146         if(opt_codec_ctx) {\r
 147                 if(opt_codec_ctx->max_stack_size) {\r
 148                         s_codec_ctx = *opt_codec_ctx;\r
 149                         opt_codec_ctx = &s_codec_ctx;\r
 150                 }\r
 151         } else {\r
 152                 /* If context is not given, be security-conscious anyway */\r
 153                 memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));\r
 154                 s_codec_ctx.max_stack_size = ASN__DEFAULT_STACK_MAX;\r
 155                 opt_codec_ctx = &s_codec_ctx;\r
 156         }\r
 157 \r
 158         /* Fill in the position indicator */\r
 159         memset(&pd, 0, sizeof(pd));\r
 160         pd.buffer = (const uint8_t *)buffer;\r
 161         pd.nboff = skip_bits;\r
 162         pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */\r
 163         if(pd.nboff > pd.nbits)\r
 164                 ASN__DECODE_FAILED;\r
 165 \r
 166         /*\r
 167          * Invoke type-specific decoder.\r
 168          */\r
 169         if(!td->op->aper_decoder)\r
 170                 ASN__DECODE_FAILED;     /* PER is not compiled in */\r
 171                 rval = td->op->aper_decoder(opt_codec_ctx, td, 0, sptr, &pd);\r
 172         if(rval.code == RC_OK) {\r
 173                 /* Return the number of consumed bits */\r
 174                 rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)\r
 175                 + pd.nboff - skip_bits;\r
 176                 ASN_DEBUG("PER decoding consumed %zu, counted %zu",\r
 177                                   rval.consumed, pd.moved);\r
 178                 assert(rval.consumed == pd.moved);\r
 179         } else {\r
 180                 /* PER codec is not a restartable */\r
 181                 rval.consumed = 0;\r
 182         }\r
 183         return rval;\r
 184 }\r
 185 \r