LCOV - code coverage report
Current view: top level - bin/default/source4/heimdal/lib/gssapi - asn1_spnego_asn1.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 1175 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 50 0.0 %

          Line data    Source code
       1             : #include "config.h"
       2             : /* Generated from /builds/samba-team/devel/samba/source4/heimdal/lib/gssapi/spnego/spnego.asn1 */
       3             : /* Do not edit */
       4             : 
       5             : #define  ASN1_LIB
       6             : 
       7             : #include <stdio.h>
       8             : #include <stdlib.h>
       9             : #include <time.h>
      10             : #include <string.h>
      11             : #include <errno.h>
      12             : #include <limits.h>
      13             : #include <krb5-types.h>
      14             : #include <spnego_asn1.h>
      15             : #include <spnego_asn1-priv.h>
      16             : #include <asn1_err.h>
      17             : #include <der.h>
      18             : #include <der-private.h>
      19             : #include <asn1-template.h>
      20             : #include <parse_units.h>
      21             : 
      22             : int ASN1CALL
      23           0 : encode_MechType(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MechType *data, size_t *size)
      24             : {
      25           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
      26             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
      27             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
      28             : 
      29           0 : e = der_put_oid(p, len, data, &l);
      30           0 : if (e) return e;
      31           0 : p -= l; len -= l; ret += l;
      32             : 
      33           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OID, &l);
      34           0 : if (e) return e;
      35           0 : p -= l; len -= l; ret += l;
      36             : 
      37           0 : *size = ret;
      38           0 : return 0;
      39             : }
      40             : 
      41             : int ASN1CALL
      42           0 : decode_MechType(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MechType *data, size_t *size)
      43             : {
      44           0 : size_t ret = 0;
      45             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
      46             : int e HEIMDAL_UNUSED_ATTRIBUTE;
      47             : 
      48           0 : memset(data, 0, sizeof(*data));
      49             : {
      50             : size_t Top_datalen, Top_oldlen;
      51             : Der_type Top_type;
      52           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_OID, &Top_datalen, &l);
      53           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
      54           0 : if(e) goto fail;
      55           0 : p += l; len -= l; ret += l;
      56           0 : Top_oldlen = len;
      57           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
      58           0 : len = Top_datalen;
      59           0 : e = der_get_oid(p, len, data, &l);
      60           0 : if(e) goto fail;
      61           0 : p += l; len -= l; ret += l;
      62           0 : len = Top_oldlen - Top_datalen;
      63             : }
      64           0 : if(size) *size = ret;
      65           0 : return 0;
      66           0 : fail:
      67           0 : free_MechType(data);
      68           0 : return e;
      69             : }
      70             : 
      71             : void ASN1CALL
      72           0 : free_MechType(MechType *data)
      73             : {
      74           0 : der_free_oid(data);
      75           0 : }
      76             : 
      77             : size_t ASN1CALL
      78           0 : length_MechType(const MechType *data)
      79             : {
      80           0 : size_t ret = 0;
      81           0 : ret += der_length_oid(data);
      82           0 : ret += 1 + der_length_len (ret);
      83           0 : return ret;
      84             : }
      85             : 
      86             : int ASN1CALL
      87           0 : copy_MechType(const MechType *from, MechType *to)
      88             : {
      89           0 : memset(to, 0, sizeof(*to));
      90           0 : if(der_copy_oid(from, to)) goto fail;
      91           0 : return 0;
      92           0 : fail:
      93           0 : free_MechType(to);
      94           0 : return ENOMEM;
      95             : }
      96             : 
      97             : int ASN1CALL
      98           0 : encode_MechTypeList(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const MechTypeList *data, size_t *size)
      99             : {
     100           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     101             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     102             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     103             : 
     104           0 : for(i = (int)(data)->len - 1; i >= 0; --i) {
     105           0 : size_t Top_tag_for_oldret = ret;
     106           0 : ret = 0;
     107           0 : e = encode_MechType(p, len, &(data)->val[i], &l);
     108           0 : if (e) return e;
     109           0 : p -= l; len -= l; ret += l;
     110             : 
     111           0 : ret += Top_tag_for_oldret;
     112             : }
     113           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
     114           0 : if (e) return e;
     115           0 : p -= l; len -= l; ret += l;
     116             : 
     117           0 : *size = ret;
     118           0 : return 0;
     119             : }
     120             : 
     121             : int ASN1CALL
     122           0 : decode_MechTypeList(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, MechTypeList *data, size_t *size)
     123             : {
     124           0 : size_t ret = 0;
     125             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     126             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     127             : 
     128           0 : memset(data, 0, sizeof(*data));
     129             : {
     130             : size_t Top_datalen, Top_oldlen;
     131             : Der_type Top_type;
     132           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
     133           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
     134           0 : if(e) goto fail;
     135           0 : p += l; len -= l; ret += l;
     136           0 : Top_oldlen = len;
     137           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     138           0 : len = Top_datalen;
     139             : {
     140           0 : size_t Top_Tag_origlen = len;
     141           0 : size_t Top_Tag_oldret = ret;
     142           0 : size_t Top_Tag_olen = 0;
     143             : void *Top_Tag_tmp;
     144           0 : ret = 0;
     145           0 : (data)->len = 0;
     146           0 : (data)->val = NULL;
     147           0 : while(ret < Top_Tag_origlen) {
     148           0 : size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
     149           0 : if (Top_Tag_olen > Top_Tag_nlen) { e = ASN1_OVERFLOW; goto fail; }
     150           0 : Top_Tag_olen = Top_Tag_nlen;
     151           0 : Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
     152           0 : if (Top_Tag_tmp == NULL) { e = ENOMEM; goto fail; }
     153           0 : (data)->val = Top_Tag_tmp;
     154           0 : e = decode_MechType(p, len, &(data)->val[(data)->len], &l);
     155           0 : if(e) goto fail;
     156           0 : p += l; len -= l; ret += l;
     157           0 : (data)->len++;
     158           0 : len = Top_Tag_origlen - ret;
     159             : }
     160           0 : ret += Top_Tag_oldret;
     161             : }
     162           0 : len = Top_oldlen - Top_datalen;
     163             : }
     164           0 : if(size) *size = ret;
     165           0 : return 0;
     166           0 : fail:
     167           0 : free_MechTypeList(data);
     168           0 : return e;
     169             : }
     170             : 
     171             : void ASN1CALL
     172           0 : free_MechTypeList(MechTypeList *data)
     173             : {
     174           0 : while((data)->len){
     175           0 : free_MechType(&(data)->val[(data)->len-1]);
     176           0 : (data)->len--;
     177             : }
     178           0 : free((data)->val);
     179           0 : (data)->val = NULL;
     180           0 : }
     181             : 
     182             : size_t ASN1CALL
     183           0 : length_MechTypeList(const MechTypeList *data)
     184             : {
     185           0 : size_t ret = 0;
     186             : {
     187           0 : size_t Top_tag_oldret = ret;
     188             : int i;
     189           0 : ret = 0;
     190           0 : for(i = (data)->len - 1; i >= 0; --i){
     191           0 : size_t Top_tag_for_oldret = ret;
     192           0 : ret = 0;
     193           0 : ret += length_MechType(&(data)->val[i]);
     194           0 : ret += Top_tag_for_oldret;
     195             : }
     196           0 : ret += Top_tag_oldret;
     197             : }
     198           0 : ret += 1 + der_length_len (ret);
     199           0 : return ret;
     200             : }
     201             : 
     202             : int ASN1CALL
     203           0 : copy_MechTypeList(const MechTypeList *from, MechTypeList *to)
     204             : {
     205           0 : memset(to, 0, sizeof(*to));
     206           0 : if(((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL && (from)->len != 0)
     207           0 : goto fail;
     208           0 : for((to)->len = 0; (to)->len < (from)->len; (to)->len++){
     209           0 : if(copy_MechType(&(from)->val[(to)->len], &(to)->val[(to)->len])) goto fail;
     210             : }
     211           0 : return 0;
     212           0 : fail:
     213           0 : free_MechTypeList(to);
     214           0 : return ENOMEM;
     215             : }
     216             : 
     217             : int ASN1CALL
     218           0 : add_MechTypeList(MechTypeList *data, const MechType *element)
     219             : {
     220             : int ret;
     221             : void *ptr;
     222             : 
     223           0 : ptr = realloc(data->val, 
     224           0 :         (data->len + 1) * sizeof(data->val[0]));
     225           0 : if (ptr == NULL) return ENOMEM;
     226           0 : data->val = ptr;
     227             : 
     228           0 : ret = copy_MechType(element, &data->val[data->len]);
     229           0 : if (ret) return ret;
     230           0 : data->len++;
     231           0 : return 0;
     232             : }
     233             : 
     234             : int ASN1CALL
     235           0 : remove_MechTypeList(MechTypeList *data, unsigned int element)
     236             : {
     237             : void *ptr;
     238             : 
     239           0 : if (data->len == 0 || element >= data->len)
     240           0 :         return ASN1_OVERRUN;
     241           0 : free_MechType(&data->val[element]);
     242           0 : data->len--;
     243           0 : if (element < data->len)
     244           0 :         memmove(&data->val[element], &data->val[element + 1], 
     245           0 :                 sizeof(data->val[0]) * data->len);
     246           0 : ptr = realloc(data->val, data->len * sizeof(data->val[0]));
     247           0 : if (ptr != NULL || data->len == 0) data->val = ptr;
     248           0 : return 0;
     249             : }
     250             : 
     251             : int ASN1CALL
     252           0 : encode_ContextFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ContextFlags *data, size_t *size)
     253             : {
     254           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     255             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     256             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     257             : 
     258             : {
     259           0 : unsigned char c = 0;
     260           0 : int rest = 0;
     261           0 : int bit_set = 0;
     262           0 : if((data)->integFlag) {
     263           0 : c |= 1<<1;
     264             : }
     265           0 : if((data)->confFlag) {
     266           0 : c |= 1<<2;
     267             : }
     268           0 : if((data)->anonFlag) {
     269           0 : c |= 1<<3;
     270             : }
     271           0 : if((data)->sequenceFlag) {
     272           0 : c |= 1<<4;
     273             : }
     274           0 : if((data)->replayFlag) {
     275           0 : c |= 1<<5;
     276             : }
     277           0 : if((data)->mutualFlag) {
     278           0 : c |= 1<<6;
     279             : }
     280           0 : if((data)->delegFlag) {
     281           0 : c |= 1<<7;
     282             : }
     283           0 : if (c != 0 || bit_set) {
     284           0 : if (len < 1) return ASN1_OVERFLOW;
     285           0 : *p-- = c; len--; ret++;
     286           0 : if (!bit_set) {
     287           0 : rest = 0;
     288           0 : if(c) { 
     289           0 : while(c) { 
     290           0 : if (c & 1) break;
     291           0 : c = c >> 1;
     292           0 : rest++;
     293             : }
     294             : }
     295             : }
     296             : }
     297           0 : if (len < 1) return ASN1_OVERFLOW;
     298           0 : *p-- = rest;
     299           0 : len -= 1;
     300           0 : ret += 1;
     301             : }
     302             : 
     303           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString, &l);
     304           0 : if (e) return e;
     305           0 : p -= l; len -= l; ret += l;
     306             : 
     307           0 : *size = ret;
     308           0 : return 0;
     309             : }
     310             : 
     311             : int ASN1CALL
     312           0 : decode_ContextFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, ContextFlags *data, size_t *size)
     313             : {
     314           0 : size_t ret = 0;
     315             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     316             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     317             : 
     318           0 : memset(data, 0, sizeof(*data));
     319             : {
     320             : size_t Top_datalen, Top_oldlen;
     321             : Der_type Top_type;
     322           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_BitString, &Top_datalen, &l);
     323           0 : if (e == 0 && Top_type != PRIM) { e = ASN1_BAD_ID; }
     324           0 : if(e) goto fail;
     325           0 : p += l; len -= l; ret += l;
     326           0 : Top_oldlen = len;
     327           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     328           0 : len = Top_datalen;
     329           0 : if (len < 1) return ASN1_OVERRUN;
     330           0 : p++; len--; ret++;
     331             : do {
     332           0 : if (len < 1) break;
     333           0 : (data)->delegFlag = (*p >> 7) & 1;
     334           0 : (data)->mutualFlag = (*p >> 6) & 1;
     335           0 : (data)->replayFlag = (*p >> 5) & 1;
     336           0 : (data)->sequenceFlag = (*p >> 4) & 1;
     337           0 : (data)->anonFlag = (*p >> 3) & 1;
     338           0 : (data)->confFlag = (*p >> 2) & 1;
     339           0 : (data)->integFlag = (*p >> 1) & 1;
     340             : } while(0);
     341           0 : p += len; ret += len;
     342           0 : len = Top_oldlen - Top_datalen;
     343             : }
     344           0 : if(size) *size = ret;
     345           0 : return 0;
     346           0 : fail:
     347           0 : free_ContextFlags(data);
     348           0 : return e;
     349             : }
     350             : 
     351             : void ASN1CALL
     352           0 : free_ContextFlags(ContextFlags *data)
     353             : {
     354           0 : }
     355             : 
     356             : size_t ASN1CALL
     357           0 : length_ContextFlags(const ContextFlags *data)
     358             : {
     359           0 : size_t ret = 0;
     360             : do {
     361           0 : if((data)->integFlag) { ret += 1; break; }
     362           0 : if((data)->confFlag) { ret += 1; break; }
     363           0 : if((data)->anonFlag) { ret += 1; break; }
     364           0 : if((data)->sequenceFlag) { ret += 1; break; }
     365           0 : if((data)->replayFlag) { ret += 1; break; }
     366           0 : if((data)->mutualFlag) { ret += 1; break; }
     367           0 : if((data)->delegFlag) { ret += 1; break; }
     368             : } while(0);
     369           0 : ret += 1;
     370           0 : ret += 1 + der_length_len (ret);
     371           0 : return ret;
     372             : }
     373             : 
     374             : int ASN1CALL
     375           0 : copy_ContextFlags(const ContextFlags *from, ContextFlags *to)
     376             : {
     377           0 : memset(to, 0, sizeof(*to));
     378           0 : *(to) = *(from);
     379           0 : return 0;
     380             : }
     381             : 
     382           0 : unsigned ContextFlags2int(ContextFlags f)
     383             : {
     384           0 : unsigned r = 0;
     385           0 : if(f.delegFlag) r |= (1U << 0);
     386           0 : if(f.mutualFlag) r |= (1U << 1);
     387           0 : if(f.replayFlag) r |= (1U << 2);
     388           0 : if(f.sequenceFlag) r |= (1U << 3);
     389           0 : if(f.anonFlag) r |= (1U << 4);
     390           0 : if(f.confFlag) r |= (1U << 5);
     391           0 : if(f.integFlag) r |= (1U << 6);
     392           0 : return r;
     393             : }
     394             : 
     395           0 : ContextFlags int2ContextFlags(unsigned n)
     396             : {
     397             :         ContextFlags flags;
     398             : 
     399           0 :         memset(&flags, 0, sizeof(flags));
     400             : 
     401           0 :         flags.delegFlag = (n >> 0) & 1;
     402           0 :         flags.mutualFlag = (n >> 1) & 1;
     403           0 :         flags.replayFlag = (n >> 2) & 1;
     404           0 :         flags.sequenceFlag = (n >> 3) & 1;
     405           0 :         flags.anonFlag = (n >> 4) & 1;
     406           0 :         flags.confFlag = (n >> 5) & 1;
     407           0 :         flags.integFlag = (n >> 6) & 1;
     408           0 :         return flags;
     409             : }
     410             : 
     411             : static struct units ContextFlags_units[] = {
     412             :         {"integFlag", 1U << 6},
     413             :         {"confFlag",  1U << 5},
     414             :         {"anonFlag",  1U << 4},
     415             :         {"sequenceFlag",      1U << 3},
     416             :         {"replayFlag",        1U << 2},
     417             :         {"mutualFlag",        1U << 1},
     418             :         {"delegFlag", 1U << 0},
     419             :         {NULL,  0}
     420             : };
     421             : 
     422           0 : const struct units * asn1_ContextFlags_units(void){
     423           0 : return ContextFlags_units;
     424             : }
     425             : 
     426             : int ASN1CALL
     427           0 : encode_NegHints(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegHints *data, size_t *size)
     428             : {
     429           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     430             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     431             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     432             : 
     433             : /* hintAddress */
     434           0 : if((data)->hintAddress) {
     435           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     436           0 : ret = 0;
     437           0 : e = der_put_octet_string(p, len, (data)->hintAddress, &l);
     438           0 : if (e) return e;
     439           0 : p -= l; len -= l; ret += l;
     440             : 
     441           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
     442           0 : if (e) return e;
     443           0 : p -= l; len -= l; ret += l;
     444             : 
     445           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
     446           0 : if (e) return e;
     447           0 : p -= l; len -= l; ret += l;
     448             : 
     449           0 : ret += Top_tag_oldret;
     450             : }
     451             : /* hintName */
     452           0 : if((data)->hintName) {
     453           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     454           0 : ret = 0;
     455           0 : e = der_put_general_string(p, len, (data)->hintName, &l);
     456           0 : if (e) return e;
     457           0 : p -= l; len -= l; ret += l;
     458             : 
     459           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_GeneralString, &l);
     460           0 : if (e) return e;
     461           0 : p -= l; len -= l; ret += l;
     462             : 
     463           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
     464           0 : if (e) return e;
     465           0 : p -= l; len -= l; ret += l;
     466             : 
     467           0 : ret += Top_tag_oldret;
     468             : }
     469           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
     470           0 : if (e) return e;
     471           0 : p -= l; len -= l; ret += l;
     472             : 
     473           0 : *size = ret;
     474           0 : return 0;
     475             : }
     476             : 
     477             : int ASN1CALL
     478           0 : decode_NegHints(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegHints *data, size_t *size)
     479             : {
     480           0 : size_t ret = 0;
     481             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     482             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     483             : 
     484           0 : memset(data, 0, sizeof(*data));
     485             : {
     486             : size_t Top_datalen, Top_oldlen;
     487             : Der_type Top_type;
     488           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
     489           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
     490           0 : if(e) goto fail;
     491           0 : p += l; len -= l; ret += l;
     492           0 : Top_oldlen = len;
     493           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     494           0 : len = Top_datalen;
     495             : {
     496             : size_t hintName_datalen, hintName_oldlen;
     497             : Der_type hintName_type;
     498           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hintName_type, 0, &hintName_datalen, &l);
     499           0 : if (e == 0 && hintName_type != CONS) { e = ASN1_BAD_ID; }
     500           0 : if(e) {
     501           0 : (data)->hintName = NULL;
     502             : } else {
     503           0 : (data)->hintName = calloc(1, sizeof(*(data)->hintName));
     504           0 : if ((data)->hintName == NULL) { e = ENOMEM; goto fail; }
     505           0 : p += l; len -= l; ret += l;
     506           0 : hintName_oldlen = len;
     507           0 : if (hintName_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     508           0 : len = hintName_datalen;
     509             : {
     510             : size_t hintName_Tag_datalen, hintName_Tag_oldlen;
     511             : Der_type hintName_Tag_type;
     512           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hintName_Tag_type, UT_GeneralString, &hintName_Tag_datalen, &l);
     513           0 : if (e == 0 && hintName_Tag_type != PRIM) { e = ASN1_BAD_ID; }
     514           0 : if(e) goto fail;
     515           0 : p += l; len -= l; ret += l;
     516           0 : hintName_Tag_oldlen = len;
     517           0 : if (hintName_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     518           0 : len = hintName_Tag_datalen;
     519           0 : e = der_get_general_string(p, len, (data)->hintName, &l);
     520           0 : if(e) goto fail;
     521           0 : p += l; len -= l; ret += l;
     522           0 : len = hintName_Tag_oldlen - hintName_Tag_datalen;
     523             : }
     524           0 : len = hintName_oldlen - hintName_datalen;
     525             : }
     526             : }
     527             : {
     528             : size_t hintAddress_datalen, hintAddress_oldlen;
     529             : Der_type hintAddress_type;
     530           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &hintAddress_type, 1, &hintAddress_datalen, &l);
     531           0 : if (e == 0 && hintAddress_type != CONS) { e = ASN1_BAD_ID; }
     532           0 : if(e) {
     533           0 : (data)->hintAddress = NULL;
     534             : } else {
     535           0 : (data)->hintAddress = calloc(1, sizeof(*(data)->hintAddress));
     536           0 : if ((data)->hintAddress == NULL) { e = ENOMEM; goto fail; }
     537           0 : p += l; len -= l; ret += l;
     538           0 : hintAddress_oldlen = len;
     539           0 : if (hintAddress_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     540           0 : len = hintAddress_datalen;
     541             : {
     542             : size_t hintAddress_Tag_datalen, hintAddress_Tag_oldlen;
     543             : Der_type hintAddress_Tag_type;
     544           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &hintAddress_Tag_type, UT_OctetString, &hintAddress_Tag_datalen, &l);
     545           0 : if (e == 0 && hintAddress_Tag_type != PRIM) { e = ASN1_BAD_ID; }
     546           0 : if(e) goto fail;
     547           0 : p += l; len -= l; ret += l;
     548           0 : hintAddress_Tag_oldlen = len;
     549           0 : if (hintAddress_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     550           0 : len = hintAddress_Tag_datalen;
     551           0 : e = der_get_octet_string(p, len, (data)->hintAddress, &l);
     552           0 : if(e) goto fail;
     553           0 : p += l; len -= l; ret += l;
     554           0 : len = hintAddress_Tag_oldlen - hintAddress_Tag_datalen;
     555             : }
     556           0 : len = hintAddress_oldlen - hintAddress_datalen;
     557             : }
     558             : }
     559           0 : len = Top_oldlen - Top_datalen;
     560             : }
     561           0 : if(size) *size = ret;
     562           0 : return 0;
     563           0 : fail:
     564           0 : free_NegHints(data);
     565           0 : return e;
     566             : }
     567             : 
     568             : void ASN1CALL
     569           0 : free_NegHints(NegHints *data)
     570             : {
     571           0 : if((data)->hintName) {
     572           0 : der_free_general_string((data)->hintName);
     573           0 : free((data)->hintName);
     574           0 : (data)->hintName = NULL;
     575             : }
     576           0 : if((data)->hintAddress) {
     577           0 : der_free_octet_string((data)->hintAddress);
     578           0 : free((data)->hintAddress);
     579           0 : (data)->hintAddress = NULL;
     580             : }
     581           0 : }
     582             : 
     583             : size_t ASN1CALL
     584           0 : length_NegHints(const NegHints *data)
     585             : {
     586           0 : size_t ret = 0;
     587           0 : if((data)->hintName){
     588           0 : size_t Top_tag_oldret = ret;
     589           0 : ret = 0;
     590           0 : ret += der_length_general_string((data)->hintName);
     591           0 : ret += 1 + der_length_len (ret);
     592           0 : ret += 1 + der_length_len (ret);
     593           0 : ret += Top_tag_oldret;
     594             : }
     595           0 : if((data)->hintAddress){
     596           0 : size_t Top_tag_oldret = ret;
     597           0 : ret = 0;
     598           0 : ret += der_length_octet_string((data)->hintAddress);
     599           0 : ret += 1 + der_length_len (ret);
     600           0 : ret += 1 + der_length_len (ret);
     601           0 : ret += Top_tag_oldret;
     602             : }
     603           0 : ret += 1 + der_length_len (ret);
     604           0 : return ret;
     605             : }
     606             : 
     607             : int ASN1CALL
     608           0 : copy_NegHints(const NegHints *from, NegHints *to)
     609             : {
     610           0 : memset(to, 0, sizeof(*to));
     611           0 : if((from)->hintName) {
     612           0 : (to)->hintName = malloc(sizeof(*(to)->hintName));
     613           0 : if((to)->hintName == NULL) goto fail;
     614           0 : if(der_copy_general_string((from)->hintName, (to)->hintName)) goto fail;
     615             : }else
     616           0 : (to)->hintName = NULL;
     617           0 : if((from)->hintAddress) {
     618           0 : (to)->hintAddress = malloc(sizeof(*(to)->hintAddress));
     619           0 : if((to)->hintAddress == NULL) goto fail;
     620           0 : if(der_copy_octet_string((from)->hintAddress, (to)->hintAddress)) goto fail;
     621             : }else
     622           0 : (to)->hintAddress = NULL;
     623           0 : return 0;
     624           0 : fail:
     625           0 : free_NegHints(to);
     626           0 : return ENOMEM;
     627             : }
     628             : 
     629             : int ASN1CALL
     630           0 : encode_NegTokenInitWin(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegTokenInitWin *data, size_t *size)
     631             : {
     632           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     633             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     634             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     635             : 
     636             : /* negHints */
     637           0 : if((data)->negHints) {
     638           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     639           0 : ret = 0;
     640           0 : e = encode_NegHints(p, len, (data)->negHints, &l);
     641           0 : if (e) return e;
     642           0 : p -= l; len -= l; ret += l;
     643             : 
     644           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
     645           0 : if (e) return e;
     646           0 : p -= l; len -= l; ret += l;
     647             : 
     648           0 : ret += Top_tag_oldret;
     649             : }
     650             : /* mechToken */
     651           0 : if((data)->mechToken) {
     652           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     653           0 : ret = 0;
     654           0 : e = der_put_octet_string(p, len, (data)->mechToken, &l);
     655           0 : if (e) return e;
     656           0 : p -= l; len -= l; ret += l;
     657             : 
     658           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
     659           0 : if (e) return e;
     660           0 : p -= l; len -= l; ret += l;
     661             : 
     662           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
     663           0 : if (e) return e;
     664           0 : p -= l; len -= l; ret += l;
     665             : 
     666           0 : ret += Top_tag_oldret;
     667             : }
     668             : /* reqFlags */
     669           0 : if((data)->reqFlags) {
     670           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     671           0 : ret = 0;
     672           0 : e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
     673           0 : if (e) return e;
     674           0 : p -= l; len -= l; ret += l;
     675             : 
     676           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
     677           0 : if (e) return e;
     678           0 : p -= l; len -= l; ret += l;
     679             : 
     680           0 : ret += Top_tag_oldret;
     681             : }
     682             : /* mechTypes */
     683             : {
     684           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     685           0 : ret = 0;
     686           0 : e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
     687           0 : if (e) return e;
     688           0 : p -= l; len -= l; ret += l;
     689             : 
     690           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
     691           0 : if (e) return e;
     692           0 : p -= l; len -= l; ret += l;
     693             : 
     694           0 : ret += Top_tag_oldret;
     695             : }
     696           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
     697           0 : if (e) return e;
     698           0 : p -= l; len -= l; ret += l;
     699             : 
     700           0 : *size = ret;
     701           0 : return 0;
     702             : }
     703             : 
     704             : int ASN1CALL
     705           0 : decode_NegTokenInitWin(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegTokenInitWin *data, size_t *size)
     706             : {
     707           0 : size_t ret = 0;
     708             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     709             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     710             : 
     711           0 : memset(data, 0, sizeof(*data));
     712             : {
     713             : size_t Top_datalen, Top_oldlen;
     714             : Der_type Top_type;
     715           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
     716           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
     717           0 : if(e) goto fail;
     718           0 : p += l; len -= l; ret += l;
     719           0 : Top_oldlen = len;
     720           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     721           0 : len = Top_datalen;
     722             : {
     723             : size_t mechTypes_datalen, mechTypes_oldlen;
     724             : Der_type mechTypes_type;
     725           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechTypes_type, 0, &mechTypes_datalen, &l);
     726           0 : if (e == 0 && mechTypes_type != CONS) { e = ASN1_BAD_ID; }
     727           0 : if(e) goto fail;
     728           0 : p += l; len -= l; ret += l;
     729           0 : mechTypes_oldlen = len;
     730           0 : if (mechTypes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     731           0 : len = mechTypes_datalen;
     732           0 : e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
     733           0 : if(e) goto fail;
     734           0 : p += l; len -= l; ret += l;
     735           0 : len = mechTypes_oldlen - mechTypes_datalen;
     736             : }
     737             : {
     738             : size_t reqFlags_datalen, reqFlags_oldlen;
     739             : Der_type reqFlags_type;
     740           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &reqFlags_type, 1, &reqFlags_datalen, &l);
     741           0 : if (e == 0 && reqFlags_type != CONS) { e = ASN1_BAD_ID; }
     742           0 : if(e) {
     743           0 : (data)->reqFlags = NULL;
     744             : } else {
     745           0 : (data)->reqFlags = calloc(1, sizeof(*(data)->reqFlags));
     746           0 : if ((data)->reqFlags == NULL) { e = ENOMEM; goto fail; }
     747           0 : p += l; len -= l; ret += l;
     748           0 : reqFlags_oldlen = len;
     749           0 : if (reqFlags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     750           0 : len = reqFlags_datalen;
     751           0 : e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
     752           0 : if(e) goto fail;
     753           0 : p += l; len -= l; ret += l;
     754           0 : len = reqFlags_oldlen - reqFlags_datalen;
     755             : }
     756             : }
     757             : {
     758             : size_t mechToken_datalen, mechToken_oldlen;
     759             : Der_type mechToken_type;
     760           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechToken_type, 2, &mechToken_datalen, &l);
     761           0 : if (e == 0 && mechToken_type != CONS) { e = ASN1_BAD_ID; }
     762           0 : if(e) {
     763           0 : (data)->mechToken = NULL;
     764             : } else {
     765           0 : (data)->mechToken = calloc(1, sizeof(*(data)->mechToken));
     766           0 : if ((data)->mechToken == NULL) { e = ENOMEM; goto fail; }
     767           0 : p += l; len -= l; ret += l;
     768           0 : mechToken_oldlen = len;
     769           0 : if (mechToken_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     770           0 : len = mechToken_datalen;
     771             : {
     772             : size_t mechToken_Tag_datalen, mechToken_Tag_oldlen;
     773             : Der_type mechToken_Tag_type;
     774           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechToken_Tag_type, UT_OctetString, &mechToken_Tag_datalen, &l);
     775           0 : if (e == 0 && mechToken_Tag_type != PRIM) { e = ASN1_BAD_ID; }
     776           0 : if(e) goto fail;
     777           0 : p += l; len -= l; ret += l;
     778           0 : mechToken_Tag_oldlen = len;
     779           0 : if (mechToken_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     780           0 : len = mechToken_Tag_datalen;
     781           0 : e = der_get_octet_string(p, len, (data)->mechToken, &l);
     782           0 : if(e) goto fail;
     783           0 : p += l; len -= l; ret += l;
     784           0 : len = mechToken_Tag_oldlen - mechToken_Tag_datalen;
     785             : }
     786           0 : len = mechToken_oldlen - mechToken_datalen;
     787             : }
     788             : }
     789             : {
     790             : size_t negHints_datalen, negHints_oldlen;
     791             : Der_type negHints_type;
     792           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negHints_type, 3, &negHints_datalen, &l);
     793           0 : if (e == 0 && negHints_type != CONS) { e = ASN1_BAD_ID; }
     794           0 : if(e) {
     795           0 : (data)->negHints = NULL;
     796             : } else {
     797           0 : (data)->negHints = calloc(1, sizeof(*(data)->negHints));
     798           0 : if ((data)->negHints == NULL) { e = ENOMEM; goto fail; }
     799           0 : p += l; len -= l; ret += l;
     800           0 : negHints_oldlen = len;
     801           0 : if (negHints_datalen > len) { e = ASN1_OVERRUN; goto fail; }
     802           0 : len = negHints_datalen;
     803           0 : e = decode_NegHints(p, len, (data)->negHints, &l);
     804           0 : if(e) goto fail;
     805           0 : p += l; len -= l; ret += l;
     806           0 : len = negHints_oldlen - negHints_datalen;
     807             : }
     808             : }
     809           0 : len = Top_oldlen - Top_datalen;
     810             : }
     811           0 : if(size) *size = ret;
     812           0 : return 0;
     813           0 : fail:
     814           0 : free_NegTokenInitWin(data);
     815           0 : return e;
     816             : }
     817             : 
     818             : void ASN1CALL
     819           0 : free_NegTokenInitWin(NegTokenInitWin *data)
     820             : {
     821           0 : free_MechTypeList(&(data)->mechTypes);
     822           0 : if((data)->reqFlags) {
     823           0 : free_ContextFlags((data)->reqFlags);
     824           0 : free((data)->reqFlags);
     825           0 : (data)->reqFlags = NULL;
     826             : }
     827           0 : if((data)->mechToken) {
     828           0 : der_free_octet_string((data)->mechToken);
     829           0 : free((data)->mechToken);
     830           0 : (data)->mechToken = NULL;
     831             : }
     832           0 : if((data)->negHints) {
     833           0 : free_NegHints((data)->negHints);
     834           0 : free((data)->negHints);
     835           0 : (data)->negHints = NULL;
     836             : }
     837           0 : }
     838             : 
     839             : size_t ASN1CALL
     840           0 : length_NegTokenInitWin(const NegTokenInitWin *data)
     841             : {
     842           0 : size_t ret = 0;
     843             : {
     844           0 : size_t Top_tag_oldret = ret;
     845           0 : ret = 0;
     846           0 : ret += length_MechTypeList(&(data)->mechTypes);
     847           0 : ret += 1 + der_length_len (ret);
     848           0 : ret += Top_tag_oldret;
     849             : }
     850           0 : if((data)->reqFlags){
     851           0 : size_t Top_tag_oldret = ret;
     852           0 : ret = 0;
     853           0 : ret += length_ContextFlags((data)->reqFlags);
     854           0 : ret += 1 + der_length_len (ret);
     855           0 : ret += Top_tag_oldret;
     856             : }
     857           0 : if((data)->mechToken){
     858           0 : size_t Top_tag_oldret = ret;
     859           0 : ret = 0;
     860           0 : ret += der_length_octet_string((data)->mechToken);
     861           0 : ret += 1 + der_length_len (ret);
     862           0 : ret += 1 + der_length_len (ret);
     863           0 : ret += Top_tag_oldret;
     864             : }
     865           0 : if((data)->negHints){
     866           0 : size_t Top_tag_oldret = ret;
     867           0 : ret = 0;
     868           0 : ret += length_NegHints((data)->negHints);
     869           0 : ret += 1 + der_length_len (ret);
     870           0 : ret += Top_tag_oldret;
     871             : }
     872           0 : ret += 1 + der_length_len (ret);
     873           0 : return ret;
     874             : }
     875             : 
     876             : int ASN1CALL
     877           0 : copy_NegTokenInitWin(const NegTokenInitWin *from, NegTokenInitWin *to)
     878             : {
     879           0 : memset(to, 0, sizeof(*to));
     880           0 : if(copy_MechTypeList(&(from)->mechTypes, &(to)->mechTypes)) goto fail;
     881           0 : if((from)->reqFlags) {
     882           0 : (to)->reqFlags = malloc(sizeof(*(to)->reqFlags));
     883           0 : if((to)->reqFlags == NULL) goto fail;
     884           0 : if(copy_ContextFlags((from)->reqFlags, (to)->reqFlags)) goto fail;
     885             : }else
     886           0 : (to)->reqFlags = NULL;
     887           0 : if((from)->mechToken) {
     888           0 : (to)->mechToken = malloc(sizeof(*(to)->mechToken));
     889           0 : if((to)->mechToken == NULL) goto fail;
     890           0 : if(der_copy_octet_string((from)->mechToken, (to)->mechToken)) goto fail;
     891             : }else
     892           0 : (to)->mechToken = NULL;
     893           0 : if((from)->negHints) {
     894           0 : (to)->negHints = malloc(sizeof(*(to)->negHints));
     895           0 : if((to)->negHints == NULL) goto fail;
     896           0 : if(copy_NegHints((from)->negHints, (to)->negHints)) goto fail;
     897             : }else
     898           0 : (to)->negHints = NULL;
     899           0 : return 0;
     900           0 : fail:
     901           0 : free_NegTokenInitWin(to);
     902           0 : return ENOMEM;
     903             : }
     904             : 
     905             : int ASN1CALL
     906           0 : encode_NegTokenInit(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegTokenInit *data, size_t *size)
     907             : {
     908           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
     909             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     910             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
     911             : 
     912             : /* mechListMIC */
     913           0 : if((data)->mechListMIC) {
     914           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     915           0 : ret = 0;
     916           0 : e = der_put_octet_string(p, len, (data)->mechListMIC, &l);
     917           0 : if (e) return e;
     918           0 : p -= l; len -= l; ret += l;
     919             : 
     920           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
     921           0 : if (e) return e;
     922           0 : p -= l; len -= l; ret += l;
     923             : 
     924           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
     925           0 : if (e) return e;
     926           0 : p -= l; len -= l; ret += l;
     927             : 
     928           0 : ret += Top_tag_oldret;
     929             : }
     930             : /* mechToken */
     931           0 : if((data)->mechToken) {
     932           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     933           0 : ret = 0;
     934           0 : e = der_put_octet_string(p, len, (data)->mechToken, &l);
     935           0 : if (e) return e;
     936           0 : p -= l; len -= l; ret += l;
     937             : 
     938           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
     939           0 : if (e) return e;
     940           0 : p -= l; len -= l; ret += l;
     941             : 
     942           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
     943           0 : if (e) return e;
     944           0 : p -= l; len -= l; ret += l;
     945             : 
     946           0 : ret += Top_tag_oldret;
     947             : }
     948             : /* reqFlags */
     949           0 : if((data)->reqFlags) {
     950           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     951           0 : ret = 0;
     952           0 : e = encode_ContextFlags(p, len, (data)->reqFlags, &l);
     953           0 : if (e) return e;
     954           0 : p -= l; len -= l; ret += l;
     955             : 
     956           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
     957           0 : if (e) return e;
     958           0 : p -= l; len -= l; ret += l;
     959             : 
     960           0 : ret += Top_tag_oldret;
     961             : }
     962             : /* mechTypes */
     963             : {
     964           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
     965           0 : ret = 0;
     966           0 : e = encode_MechTypeList(p, len, &(data)->mechTypes, &l);
     967           0 : if (e) return e;
     968           0 : p -= l; len -= l; ret += l;
     969             : 
     970           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
     971           0 : if (e) return e;
     972           0 : p -= l; len -= l; ret += l;
     973             : 
     974           0 : ret += Top_tag_oldret;
     975             : }
     976           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
     977           0 : if (e) return e;
     978           0 : p -= l; len -= l; ret += l;
     979             : 
     980           0 : *size = ret;
     981           0 : return 0;
     982             : }
     983             : 
     984             : int ASN1CALL
     985           0 : decode_NegTokenInit(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegTokenInit *data, size_t *size)
     986             : {
     987           0 : size_t ret = 0;
     988             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
     989             : int e HEIMDAL_UNUSED_ATTRIBUTE;
     990             : 
     991           0 : memset(data, 0, sizeof(*data));
     992             : {
     993             : size_t Top_datalen, Top_oldlen;
     994             : Der_type Top_type;
     995           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
     996           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
     997           0 : if(e) goto fail;
     998           0 : p += l; len -= l; ret += l;
     999           0 : Top_oldlen = len;
    1000           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1001           0 : len = Top_datalen;
    1002             : {
    1003             : size_t mechTypes_datalen, mechTypes_oldlen;
    1004             : Der_type mechTypes_type;
    1005           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechTypes_type, 0, &mechTypes_datalen, &l);
    1006           0 : if (e == 0 && mechTypes_type != CONS) { e = ASN1_BAD_ID; }
    1007           0 : if(e) goto fail;
    1008           0 : p += l; len -= l; ret += l;
    1009           0 : mechTypes_oldlen = len;
    1010           0 : if (mechTypes_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1011           0 : len = mechTypes_datalen;
    1012           0 : e = decode_MechTypeList(p, len, &(data)->mechTypes, &l);
    1013           0 : if(e) goto fail;
    1014           0 : p += l; len -= l; ret += l;
    1015           0 : len = mechTypes_oldlen - mechTypes_datalen;
    1016             : }
    1017             : {
    1018             : size_t reqFlags_datalen, reqFlags_oldlen;
    1019             : Der_type reqFlags_type;
    1020           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &reqFlags_type, 1, &reqFlags_datalen, &l);
    1021           0 : if (e == 0 && reqFlags_type != CONS) { e = ASN1_BAD_ID; }
    1022           0 : if(e) {
    1023           0 : (data)->reqFlags = NULL;
    1024             : } else {
    1025           0 : (data)->reqFlags = calloc(1, sizeof(*(data)->reqFlags));
    1026           0 : if ((data)->reqFlags == NULL) { e = ENOMEM; goto fail; }
    1027           0 : p += l; len -= l; ret += l;
    1028           0 : reqFlags_oldlen = len;
    1029           0 : if (reqFlags_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1030           0 : len = reqFlags_datalen;
    1031           0 : e = decode_ContextFlags(p, len, (data)->reqFlags, &l);
    1032           0 : if(e) goto fail;
    1033           0 : p += l; len -= l; ret += l;
    1034           0 : len = reqFlags_oldlen - reqFlags_datalen;
    1035             : }
    1036             : }
    1037             : {
    1038             : size_t mechToken_datalen, mechToken_oldlen;
    1039             : Der_type mechToken_type;
    1040           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechToken_type, 2, &mechToken_datalen, &l);
    1041           0 : if (e == 0 && mechToken_type != CONS) { e = ASN1_BAD_ID; }
    1042           0 : if(e) {
    1043           0 : (data)->mechToken = NULL;
    1044             : } else {
    1045           0 : (data)->mechToken = calloc(1, sizeof(*(data)->mechToken));
    1046           0 : if ((data)->mechToken == NULL) { e = ENOMEM; goto fail; }
    1047           0 : p += l; len -= l; ret += l;
    1048           0 : mechToken_oldlen = len;
    1049           0 : if (mechToken_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1050           0 : len = mechToken_datalen;
    1051             : {
    1052             : size_t mechToken_Tag_datalen, mechToken_Tag_oldlen;
    1053             : Der_type mechToken_Tag_type;
    1054           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechToken_Tag_type, UT_OctetString, &mechToken_Tag_datalen, &l);
    1055           0 : if (e == 0 && mechToken_Tag_type != PRIM) { e = ASN1_BAD_ID; }
    1056           0 : if(e) goto fail;
    1057           0 : p += l; len -= l; ret += l;
    1058           0 : mechToken_Tag_oldlen = len;
    1059           0 : if (mechToken_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1060           0 : len = mechToken_Tag_datalen;
    1061           0 : e = der_get_octet_string(p, len, (data)->mechToken, &l);
    1062           0 : if(e) goto fail;
    1063           0 : p += l; len -= l; ret += l;
    1064           0 : len = mechToken_Tag_oldlen - mechToken_Tag_datalen;
    1065             : }
    1066           0 : len = mechToken_oldlen - mechToken_datalen;
    1067             : }
    1068             : }
    1069             : {
    1070             : size_t mechListMIC_datalen, mechListMIC_oldlen;
    1071             : Der_type mechListMIC_type;
    1072           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechListMIC_type, 3, &mechListMIC_datalen, &l);
    1073           0 : if (e == 0 && mechListMIC_type != CONS) { e = ASN1_BAD_ID; }
    1074           0 : if(e) {
    1075           0 : (data)->mechListMIC = NULL;
    1076             : } else {
    1077           0 : (data)->mechListMIC = calloc(1, sizeof(*(data)->mechListMIC));
    1078           0 : if ((data)->mechListMIC == NULL) { e = ENOMEM; goto fail; }
    1079           0 : p += l; len -= l; ret += l;
    1080           0 : mechListMIC_oldlen = len;
    1081           0 : if (mechListMIC_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1082           0 : len = mechListMIC_datalen;
    1083             : {
    1084             : size_t mechListMIC_Tag_datalen, mechListMIC_Tag_oldlen;
    1085             : Der_type mechListMIC_Tag_type;
    1086           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechListMIC_Tag_type, UT_OctetString, &mechListMIC_Tag_datalen, &l);
    1087           0 : if (e == 0 && mechListMIC_Tag_type != PRIM) { e = ASN1_BAD_ID; }
    1088           0 : if(e) goto fail;
    1089           0 : p += l; len -= l; ret += l;
    1090           0 : mechListMIC_Tag_oldlen = len;
    1091           0 : if (mechListMIC_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1092           0 : len = mechListMIC_Tag_datalen;
    1093           0 : e = der_get_octet_string(p, len, (data)->mechListMIC, &l);
    1094           0 : if(e) goto fail;
    1095           0 : p += l; len -= l; ret += l;
    1096           0 : len = mechListMIC_Tag_oldlen - mechListMIC_Tag_datalen;
    1097             : }
    1098           0 : len = mechListMIC_oldlen - mechListMIC_datalen;
    1099             : }
    1100             : }
    1101           0 : len = Top_oldlen - Top_datalen;
    1102             : }
    1103           0 : if(size) *size = ret;
    1104           0 : return 0;
    1105           0 : fail:
    1106           0 : free_NegTokenInit(data);
    1107           0 : return e;
    1108             : }
    1109             : 
    1110             : void ASN1CALL
    1111           0 : free_NegTokenInit(NegTokenInit *data)
    1112             : {
    1113           0 : free_MechTypeList(&(data)->mechTypes);
    1114           0 : if((data)->reqFlags) {
    1115           0 : free_ContextFlags((data)->reqFlags);
    1116           0 : free((data)->reqFlags);
    1117           0 : (data)->reqFlags = NULL;
    1118             : }
    1119           0 : if((data)->mechToken) {
    1120           0 : der_free_octet_string((data)->mechToken);
    1121           0 : free((data)->mechToken);
    1122           0 : (data)->mechToken = NULL;
    1123             : }
    1124           0 : if((data)->mechListMIC) {
    1125           0 : der_free_octet_string((data)->mechListMIC);
    1126           0 : free((data)->mechListMIC);
    1127           0 : (data)->mechListMIC = NULL;
    1128             : }
    1129           0 : }
    1130             : 
    1131             : size_t ASN1CALL
    1132           0 : length_NegTokenInit(const NegTokenInit *data)
    1133             : {
    1134           0 : size_t ret = 0;
    1135             : {
    1136           0 : size_t Top_tag_oldret = ret;
    1137           0 : ret = 0;
    1138           0 : ret += length_MechTypeList(&(data)->mechTypes);
    1139           0 : ret += 1 + der_length_len (ret);
    1140           0 : ret += Top_tag_oldret;
    1141             : }
    1142           0 : if((data)->reqFlags){
    1143           0 : size_t Top_tag_oldret = ret;
    1144           0 : ret = 0;
    1145           0 : ret += length_ContextFlags((data)->reqFlags);
    1146           0 : ret += 1 + der_length_len (ret);
    1147           0 : ret += Top_tag_oldret;
    1148             : }
    1149           0 : if((data)->mechToken){
    1150           0 : size_t Top_tag_oldret = ret;
    1151           0 : ret = 0;
    1152           0 : ret += der_length_octet_string((data)->mechToken);
    1153           0 : ret += 1 + der_length_len (ret);
    1154           0 : ret += 1 + der_length_len (ret);
    1155           0 : ret += Top_tag_oldret;
    1156             : }
    1157           0 : if((data)->mechListMIC){
    1158           0 : size_t Top_tag_oldret = ret;
    1159           0 : ret = 0;
    1160           0 : ret += der_length_octet_string((data)->mechListMIC);
    1161           0 : ret += 1 + der_length_len (ret);
    1162           0 : ret += 1 + der_length_len (ret);
    1163           0 : ret += Top_tag_oldret;
    1164             : }
    1165           0 : ret += 1 + der_length_len (ret);
    1166           0 : return ret;
    1167             : }
    1168             : 
    1169             : int ASN1CALL
    1170           0 : copy_NegTokenInit(const NegTokenInit *from, NegTokenInit *to)
    1171             : {
    1172           0 : memset(to, 0, sizeof(*to));
    1173           0 : if(copy_MechTypeList(&(from)->mechTypes, &(to)->mechTypes)) goto fail;
    1174           0 : if((from)->reqFlags) {
    1175           0 : (to)->reqFlags = malloc(sizeof(*(to)->reqFlags));
    1176           0 : if((to)->reqFlags == NULL) goto fail;
    1177           0 : if(copy_ContextFlags((from)->reqFlags, (to)->reqFlags)) goto fail;
    1178             : }else
    1179           0 : (to)->reqFlags = NULL;
    1180           0 : if((from)->mechToken) {
    1181           0 : (to)->mechToken = malloc(sizeof(*(to)->mechToken));
    1182           0 : if((to)->mechToken == NULL) goto fail;
    1183           0 : if(der_copy_octet_string((from)->mechToken, (to)->mechToken)) goto fail;
    1184             : }else
    1185           0 : (to)->mechToken = NULL;
    1186           0 : if((from)->mechListMIC) {
    1187           0 : (to)->mechListMIC = malloc(sizeof(*(to)->mechListMIC));
    1188           0 : if((to)->mechListMIC == NULL) goto fail;
    1189           0 : if(der_copy_octet_string((from)->mechListMIC, (to)->mechListMIC)) goto fail;
    1190             : }else
    1191           0 : (to)->mechListMIC = NULL;
    1192           0 : return 0;
    1193           0 : fail:
    1194           0 : free_NegTokenInit(to);
    1195           0 : return ENOMEM;
    1196             : }
    1197             : 
    1198             : int ASN1CALL
    1199           0 : encode_NegTokenResp(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegTokenResp *data, size_t *size)
    1200             : {
    1201           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1202             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1203             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1204             : 
    1205             : /* mechListMIC */
    1206           0 : if((data)->mechListMIC) {
    1207           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1208           0 : ret = 0;
    1209           0 : e = der_put_octet_string(p, len, (data)->mechListMIC, &l);
    1210           0 : if (e) return e;
    1211           0 : p -= l; len -= l; ret += l;
    1212             : 
    1213           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    1214           0 : if (e) return e;
    1215           0 : p -= l; len -= l; ret += l;
    1216             : 
    1217           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 3, &l);
    1218           0 : if (e) return e;
    1219           0 : p -= l; len -= l; ret += l;
    1220             : 
    1221           0 : ret += Top_tag_oldret;
    1222             : }
    1223             : /* responseToken */
    1224           0 : if((data)->responseToken) {
    1225           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1226           0 : ret = 0;
    1227           0 : e = der_put_octet_string(p, len, (data)->responseToken, &l);
    1228           0 : if (e) return e;
    1229           0 : p -= l; len -= l; ret += l;
    1230             : 
    1231           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_OctetString, &l);
    1232           0 : if (e) return e;
    1233           0 : p -= l; len -= l; ret += l;
    1234             : 
    1235           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 2, &l);
    1236           0 : if (e) return e;
    1237           0 : p -= l; len -= l; ret += l;
    1238             : 
    1239           0 : ret += Top_tag_oldret;
    1240             : }
    1241             : /* supportedMech */
    1242           0 : if((data)->supportedMech) {
    1243           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1244           0 : ret = 0;
    1245           0 : e = encode_MechType(p, len, (data)->supportedMech, &l);
    1246           0 : if (e) return e;
    1247           0 : p -= l; len -= l; ret += l;
    1248             : 
    1249           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
    1250           0 : if (e) return e;
    1251           0 : p -= l; len -= l; ret += l;
    1252             : 
    1253           0 : ret += Top_tag_oldret;
    1254             : }
    1255             : /* negResult */
    1256           0 : if((data)->negResult) {
    1257           0 : size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
    1258           0 : ret = 0;
    1259             : {
    1260           0 : int enumint = (int)*(data)->negResult;
    1261           0 : e = der_put_integer(p, len, &enumint, &l);
    1262           0 : if (e) return e;
    1263           0 : p -= l; len -= l; ret += l;
    1264             : 
    1265             : }
    1266           0 : ;e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, PRIM, UT_Enumerated, &l);
    1267           0 : if (e) return e;
    1268           0 : p -= l; len -= l; ret += l;
    1269             : 
    1270           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    1271           0 : if (e) return e;
    1272           0 : p -= l; len -= l; ret += l;
    1273             : 
    1274           0 : ret += Top_tag_oldret;
    1275             : }
    1276           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence, &l);
    1277           0 : if (e) return e;
    1278           0 : p -= l; len -= l; ret += l;
    1279             : 
    1280           0 : *size = ret;
    1281           0 : return 0;
    1282             : }
    1283             : 
    1284             : int ASN1CALL
    1285           0 : decode_NegTokenResp(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegTokenResp *data, size_t *size)
    1286             : {
    1287           0 : size_t ret = 0;
    1288             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1289             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1290             : 
    1291           0 : memset(data, 0, sizeof(*data));
    1292             : {
    1293             : size_t Top_datalen, Top_oldlen;
    1294             : Der_type Top_type;
    1295           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type, UT_Sequence, &Top_datalen, &l);
    1296           0 : if (e == 0 && Top_type != CONS) { e = ASN1_BAD_ID; }
    1297           0 : if(e) goto fail;
    1298           0 : p += l; len -= l; ret += l;
    1299           0 : Top_oldlen = len;
    1300           0 : if (Top_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1301           0 : len = Top_datalen;
    1302             : {
    1303             : size_t negResult_datalen, negResult_oldlen;
    1304             : Der_type negResult_type;
    1305           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negResult_type, 0, &negResult_datalen, &l);
    1306           0 : if (e == 0 && negResult_type != CONS) { e = ASN1_BAD_ID; }
    1307           0 : if(e) {
    1308           0 : (data)->negResult = NULL;
    1309             : } else {
    1310           0 : (data)->negResult = calloc(1, sizeof(*(data)->negResult));
    1311           0 : if ((data)->negResult == NULL) { e = ENOMEM; goto fail; }
    1312           0 : p += l; len -= l; ret += l;
    1313           0 : negResult_oldlen = len;
    1314           0 : if (negResult_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1315           0 : len = negResult_datalen;
    1316             : {
    1317             : size_t negResult_Tag_datalen, negResult_Tag_oldlen;
    1318             : Der_type negResult_Tag_type;
    1319           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &negResult_Tag_type, UT_Enumerated, &negResult_Tag_datalen, &l);
    1320           0 : if (e == 0 && negResult_Tag_type != PRIM) { e = ASN1_BAD_ID; }
    1321           0 : if(e) goto fail;
    1322           0 : p += l; len -= l; ret += l;
    1323           0 : negResult_Tag_oldlen = len;
    1324           0 : if (negResult_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1325           0 : len = negResult_Tag_datalen;
    1326             : {
    1327             : int enumint;
    1328           0 : e = der_get_integer(p, len, &enumint, &l);
    1329           0 : if(e) goto fail;
    1330           0 : p += l; len -= l; ret += l;
    1331           0 : *(data)->negResult = enumint;
    1332             : }
    1333           0 : len = negResult_Tag_oldlen - negResult_Tag_datalen;
    1334             : }
    1335           0 : len = negResult_oldlen - negResult_datalen;
    1336             : }
    1337             : }
    1338             : {
    1339             : size_t supportedMech_datalen, supportedMech_oldlen;
    1340             : Der_type supportedMech_type;
    1341           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &supportedMech_type, 1, &supportedMech_datalen, &l);
    1342           0 : if (e == 0 && supportedMech_type != CONS) { e = ASN1_BAD_ID; }
    1343           0 : if(e) {
    1344           0 : (data)->supportedMech = NULL;
    1345             : } else {
    1346           0 : (data)->supportedMech = calloc(1, sizeof(*(data)->supportedMech));
    1347           0 : if ((data)->supportedMech == NULL) { e = ENOMEM; goto fail; }
    1348           0 : p += l; len -= l; ret += l;
    1349           0 : supportedMech_oldlen = len;
    1350           0 : if (supportedMech_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1351           0 : len = supportedMech_datalen;
    1352           0 : e = decode_MechType(p, len, (data)->supportedMech, &l);
    1353           0 : if(e) goto fail;
    1354           0 : p += l; len -= l; ret += l;
    1355           0 : len = supportedMech_oldlen - supportedMech_datalen;
    1356             : }
    1357             : }
    1358             : {
    1359             : size_t responseToken_datalen, responseToken_oldlen;
    1360             : Der_type responseToken_type;
    1361           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &responseToken_type, 2, &responseToken_datalen, &l);
    1362           0 : if (e == 0 && responseToken_type != CONS) { e = ASN1_BAD_ID; }
    1363           0 : if(e) {
    1364           0 : (data)->responseToken = NULL;
    1365             : } else {
    1366           0 : (data)->responseToken = calloc(1, sizeof(*(data)->responseToken));
    1367           0 : if ((data)->responseToken == NULL) { e = ENOMEM; goto fail; }
    1368           0 : p += l; len -= l; ret += l;
    1369           0 : responseToken_oldlen = len;
    1370           0 : if (responseToken_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1371           0 : len = responseToken_datalen;
    1372             : {
    1373             : size_t responseToken_Tag_datalen, responseToken_Tag_oldlen;
    1374             : Der_type responseToken_Tag_type;
    1375           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &responseToken_Tag_type, UT_OctetString, &responseToken_Tag_datalen, &l);
    1376           0 : if (e == 0 && responseToken_Tag_type != PRIM) { e = ASN1_BAD_ID; }
    1377           0 : if(e) goto fail;
    1378           0 : p += l; len -= l; ret += l;
    1379           0 : responseToken_Tag_oldlen = len;
    1380           0 : if (responseToken_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1381           0 : len = responseToken_Tag_datalen;
    1382           0 : e = der_get_octet_string(p, len, (data)->responseToken, &l);
    1383           0 : if(e) goto fail;
    1384           0 : p += l; len -= l; ret += l;
    1385           0 : len = responseToken_Tag_oldlen - responseToken_Tag_datalen;
    1386             : }
    1387           0 : len = responseToken_oldlen - responseToken_datalen;
    1388             : }
    1389             : }
    1390             : {
    1391             : size_t mechListMIC_datalen, mechListMIC_oldlen;
    1392             : Der_type mechListMIC_type;
    1393           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &mechListMIC_type, 3, &mechListMIC_datalen, &l);
    1394           0 : if (e == 0 && mechListMIC_type != CONS) { e = ASN1_BAD_ID; }
    1395           0 : if(e) {
    1396           0 : (data)->mechListMIC = NULL;
    1397             : } else {
    1398           0 : (data)->mechListMIC = calloc(1, sizeof(*(data)->mechListMIC));
    1399           0 : if ((data)->mechListMIC == NULL) { e = ENOMEM; goto fail; }
    1400           0 : p += l; len -= l; ret += l;
    1401           0 : mechListMIC_oldlen = len;
    1402           0 : if (mechListMIC_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1403           0 : len = mechListMIC_datalen;
    1404             : {
    1405             : size_t mechListMIC_Tag_datalen, mechListMIC_Tag_oldlen;
    1406             : Der_type mechListMIC_Tag_type;
    1407           0 : e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &mechListMIC_Tag_type, UT_OctetString, &mechListMIC_Tag_datalen, &l);
    1408           0 : if (e == 0 && mechListMIC_Tag_type != PRIM) { e = ASN1_BAD_ID; }
    1409           0 : if(e) goto fail;
    1410           0 : p += l; len -= l; ret += l;
    1411           0 : mechListMIC_Tag_oldlen = len;
    1412           0 : if (mechListMIC_Tag_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1413           0 : len = mechListMIC_Tag_datalen;
    1414           0 : e = der_get_octet_string(p, len, (data)->mechListMIC, &l);
    1415           0 : if(e) goto fail;
    1416           0 : p += l; len -= l; ret += l;
    1417           0 : len = mechListMIC_Tag_oldlen - mechListMIC_Tag_datalen;
    1418             : }
    1419           0 : len = mechListMIC_oldlen - mechListMIC_datalen;
    1420             : }
    1421             : }
    1422           0 : len = Top_oldlen - Top_datalen;
    1423             : }
    1424           0 : if(size) *size = ret;
    1425           0 : return 0;
    1426           0 : fail:
    1427           0 : free_NegTokenResp(data);
    1428           0 : return e;
    1429             : }
    1430             : 
    1431             : void ASN1CALL
    1432           0 : free_NegTokenResp(NegTokenResp *data)
    1433             : {
    1434           0 : if((data)->negResult) {
    1435           0 : free((data)->negResult);
    1436           0 : (data)->negResult = NULL;
    1437             : }
    1438           0 : if((data)->supportedMech) {
    1439           0 : free_MechType((data)->supportedMech);
    1440           0 : free((data)->supportedMech);
    1441           0 : (data)->supportedMech = NULL;
    1442             : }
    1443           0 : if((data)->responseToken) {
    1444           0 : der_free_octet_string((data)->responseToken);
    1445           0 : free((data)->responseToken);
    1446           0 : (data)->responseToken = NULL;
    1447             : }
    1448           0 : if((data)->mechListMIC) {
    1449           0 : der_free_octet_string((data)->mechListMIC);
    1450           0 : free((data)->mechListMIC);
    1451           0 : (data)->mechListMIC = NULL;
    1452             : }
    1453           0 : }
    1454             : 
    1455             : size_t ASN1CALL
    1456           0 : length_NegTokenResp(const NegTokenResp *data)
    1457             : {
    1458           0 : size_t ret = 0;
    1459           0 : if((data)->negResult){
    1460           0 : size_t Top_tag_oldret = ret;
    1461           0 : ret = 0;
    1462             : {
    1463           0 : int enumint = *(data)->negResult;
    1464           0 : ret += der_length_integer(&enumint);
    1465             : }
    1466           0 : ret += 1 + der_length_len (ret);
    1467           0 : ret += 1 + der_length_len (ret);
    1468           0 : ret += Top_tag_oldret;
    1469             : }
    1470           0 : if((data)->supportedMech){
    1471           0 : size_t Top_tag_oldret = ret;
    1472           0 : ret = 0;
    1473           0 : ret += length_MechType((data)->supportedMech);
    1474           0 : ret += 1 + der_length_len (ret);
    1475           0 : ret += Top_tag_oldret;
    1476             : }
    1477           0 : if((data)->responseToken){
    1478           0 : size_t Top_tag_oldret = ret;
    1479           0 : ret = 0;
    1480           0 : ret += der_length_octet_string((data)->responseToken);
    1481           0 : ret += 1 + der_length_len (ret);
    1482           0 : ret += 1 + der_length_len (ret);
    1483           0 : ret += Top_tag_oldret;
    1484             : }
    1485           0 : if((data)->mechListMIC){
    1486           0 : size_t Top_tag_oldret = ret;
    1487           0 : ret = 0;
    1488           0 : ret += der_length_octet_string((data)->mechListMIC);
    1489           0 : ret += 1 + der_length_len (ret);
    1490           0 : ret += 1 + der_length_len (ret);
    1491           0 : ret += Top_tag_oldret;
    1492             : }
    1493           0 : ret += 1 + der_length_len (ret);
    1494           0 : return ret;
    1495             : }
    1496             : 
    1497             : int ASN1CALL
    1498           0 : copy_NegTokenResp(const NegTokenResp *from, NegTokenResp *to)
    1499             : {
    1500           0 : memset(to, 0, sizeof(*to));
    1501           0 : if((from)->negResult) {
    1502           0 : (to)->negResult = malloc(sizeof(*(to)->negResult));
    1503           0 : if((to)->negResult == NULL) goto fail;
    1504           0 : *((to)->negResult) = *((from)->negResult);
    1505             : }else
    1506           0 : (to)->negResult = NULL;
    1507           0 : if((from)->supportedMech) {
    1508           0 : (to)->supportedMech = malloc(sizeof(*(to)->supportedMech));
    1509           0 : if((to)->supportedMech == NULL) goto fail;
    1510           0 : if(copy_MechType((from)->supportedMech, (to)->supportedMech)) goto fail;
    1511             : }else
    1512           0 : (to)->supportedMech = NULL;
    1513           0 : if((from)->responseToken) {
    1514           0 : (to)->responseToken = malloc(sizeof(*(to)->responseToken));
    1515           0 : if((to)->responseToken == NULL) goto fail;
    1516           0 : if(der_copy_octet_string((from)->responseToken, (to)->responseToken)) goto fail;
    1517             : }else
    1518           0 : (to)->responseToken = NULL;
    1519           0 : if((from)->mechListMIC) {
    1520           0 : (to)->mechListMIC = malloc(sizeof(*(to)->mechListMIC));
    1521           0 : if((to)->mechListMIC == NULL) goto fail;
    1522           0 : if(der_copy_octet_string((from)->mechListMIC, (to)->mechListMIC)) goto fail;
    1523             : }else
    1524           0 : (to)->mechListMIC = NULL;
    1525           0 : return 0;
    1526           0 : fail:
    1527           0 : free_NegTokenResp(to);
    1528           0 : return ENOMEM;
    1529             : }
    1530             : 
    1531             : int ASN1CALL
    1532           0 : encode_NegotiationToken(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegotiationToken *data, size_t *size)
    1533             : {
    1534           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1535             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1536             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1537             : 
    1538             : 
    1539           0 : switch((data)->element) {
    1540           0 : case choice_NegotiationToken_negTokenResp: {size_t Top_oldret = ret;
    1541           0 : ret = 0;
    1542           0 : e = encode_NegTokenResp(p, len, &((data))->u.negTokenResp, &l);
    1543           0 : if (e) return e;
    1544           0 : p -= l; len -= l; ret += l;
    1545             : 
    1546           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
    1547           0 : if (e) return e;
    1548           0 : p -= l; len -= l; ret += l;
    1549             : 
    1550           0 : ret += Top_oldret;
    1551           0 : break;
    1552             : }
    1553           0 : case choice_NegotiationToken_negTokenInit: {size_t Top_oldret = ret;
    1554           0 : ret = 0;
    1555           0 : e = encode_NegTokenInit(p, len, &((data))->u.negTokenInit, &l);
    1556           0 : if (e) return e;
    1557           0 : p -= l; len -= l; ret += l;
    1558             : 
    1559           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    1560           0 : if (e) return e;
    1561           0 : p -= l; len -= l; ret += l;
    1562             : 
    1563           0 : ret += Top_oldret;
    1564           0 : break;
    1565             : }
    1566             : };
    1567           0 : *size = ret;
    1568           0 : return 0;
    1569             : }
    1570             : 
    1571             : int ASN1CALL
    1572           0 : decode_NegotiationToken(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegotiationToken *data, size_t *size)
    1573             : {
    1574           0 : size_t ret = 0;
    1575             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1576             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1577             : 
    1578           0 : memset(data, 0, sizeof(*data));
    1579           0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
    1580             : {
    1581             : size_t negTokenInit_datalen, negTokenInit_oldlen;
    1582             : Der_type negTokenInit_type;
    1583           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negTokenInit_type, 0, &negTokenInit_datalen, &l);
    1584           0 : if (e == 0 && negTokenInit_type != CONS) { e = ASN1_BAD_ID; }
    1585           0 : if(e) goto fail;
    1586           0 : p += l; len -= l; ret += l;
    1587           0 : negTokenInit_oldlen = len;
    1588           0 : if (negTokenInit_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1589           0 : len = negTokenInit_datalen;
    1590           0 : e = decode_NegTokenInit(p, len, &(data)->u.negTokenInit, &l);
    1591           0 : if(e) goto fail;
    1592           0 : p += l; len -= l; ret += l;
    1593           0 : len = negTokenInit_oldlen - negTokenInit_datalen;
    1594             : }
    1595           0 : (data)->element = choice_NegotiationToken_negTokenInit;
    1596             : }
    1597           0 : else if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 1, NULL) == 0) {
    1598             : {
    1599             : size_t negTokenResp_datalen, negTokenResp_oldlen;
    1600             : Der_type negTokenResp_type;
    1601           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negTokenResp_type, 1, &negTokenResp_datalen, &l);
    1602           0 : if (e == 0 && negTokenResp_type != CONS) { e = ASN1_BAD_ID; }
    1603           0 : if(e) goto fail;
    1604           0 : p += l; len -= l; ret += l;
    1605           0 : negTokenResp_oldlen = len;
    1606           0 : if (negTokenResp_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1607           0 : len = negTokenResp_datalen;
    1608           0 : e = decode_NegTokenResp(p, len, &(data)->u.negTokenResp, &l);
    1609           0 : if(e) goto fail;
    1610           0 : p += l; len -= l; ret += l;
    1611           0 : len = negTokenResp_oldlen - negTokenResp_datalen;
    1612             : }
    1613           0 : (data)->element = choice_NegotiationToken_negTokenResp;
    1614             : }
    1615             : else {
    1616           0 : e = ASN1_PARSE_ERROR;
    1617           0 : goto fail;
    1618             : }
    1619           0 : if(size) *size = ret;
    1620           0 : return 0;
    1621           0 : fail:
    1622           0 : free_NegotiationToken(data);
    1623           0 : return e;
    1624             : }
    1625             : 
    1626             : void ASN1CALL
    1627           0 : free_NegotiationToken(NegotiationToken *data)
    1628             : {
    1629           0 : switch((data)->element) {
    1630           0 : case choice_NegotiationToken_negTokenInit:
    1631           0 : free_NegTokenInit(&(data)->u.negTokenInit);
    1632           0 : break;
    1633           0 : case choice_NegotiationToken_negTokenResp:
    1634           0 : free_NegTokenResp(&(data)->u.negTokenResp);
    1635           0 : break;
    1636             : }
    1637           0 : }
    1638             : 
    1639             : size_t ASN1CALL
    1640           0 : length_NegotiationToken(const NegotiationToken *data)
    1641             : {
    1642           0 : size_t ret = 0;
    1643           0 : switch((data)->element) {
    1644           0 : case choice_NegotiationToken_negTokenInit:
    1645             : {
    1646           0 : size_t Top_oldret = ret;
    1647           0 : ret = 0;
    1648           0 : ret += length_NegTokenInit(&(data)->u.negTokenInit);
    1649           0 : ret += 1 + der_length_len (ret);
    1650           0 : ret += Top_oldret;
    1651             : }
    1652           0 : break;
    1653           0 : case choice_NegotiationToken_negTokenResp:
    1654             : {
    1655           0 : size_t Top_oldret = ret;
    1656           0 : ret = 0;
    1657           0 : ret += length_NegTokenResp(&(data)->u.negTokenResp);
    1658           0 : ret += 1 + der_length_len (ret);
    1659           0 : ret += Top_oldret;
    1660             : }
    1661           0 : break;
    1662             : }
    1663           0 : return ret;
    1664             : }
    1665             : 
    1666             : int ASN1CALL
    1667           0 : copy_NegotiationToken(const NegotiationToken *from, NegotiationToken *to)
    1668             : {
    1669           0 : memset(to, 0, sizeof(*to));
    1670           0 : (to)->element = (from)->element;
    1671           0 : switch((from)->element) {
    1672           0 : case choice_NegotiationToken_negTokenInit:
    1673           0 : if(copy_NegTokenInit(&(from)->u.negTokenInit, &(to)->u.negTokenInit)) goto fail;
    1674           0 : break;
    1675           0 : case choice_NegotiationToken_negTokenResp:
    1676           0 : if(copy_NegTokenResp(&(from)->u.negTokenResp, &(to)->u.negTokenResp)) goto fail;
    1677           0 : break;
    1678             : }
    1679           0 : return 0;
    1680           0 : fail:
    1681           0 : free_NegotiationToken(to);
    1682           0 : return ENOMEM;
    1683             : }
    1684             : 
    1685             : int ASN1CALL
    1686           0 : encode_NegotiationTokenWin(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NegotiationTokenWin *data, size_t *size)
    1687             : {
    1688           0 : size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
    1689             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1690             : int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
    1691             : 
    1692             : 
    1693           0 : switch((data)->element) {
    1694           0 : case choice_NegotiationTokenWin_negTokenInit: {size_t Top_oldret = ret;
    1695           0 : ret = 0;
    1696           0 : e = encode_NegTokenInitWin(p, len, &((data))->u.negTokenInit, &l);
    1697           0 : if (e) return e;
    1698           0 : p -= l; len -= l; ret += l;
    1699             : 
    1700           0 : e = der_put_length_and_tag (p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
    1701           0 : if (e) return e;
    1702           0 : p -= l; len -= l; ret += l;
    1703             : 
    1704           0 : ret += Top_oldret;
    1705           0 : break;
    1706             : }
    1707             : };
    1708           0 : *size = ret;
    1709           0 : return 0;
    1710             : }
    1711             : 
    1712             : int ASN1CALL
    1713           0 : decode_NegotiationTokenWin(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE, size_t len HEIMDAL_UNUSED_ATTRIBUTE, NegotiationTokenWin *data, size_t *size)
    1714             : {
    1715           0 : size_t ret = 0;
    1716             : size_t l HEIMDAL_UNUSED_ATTRIBUTE;
    1717             : int e HEIMDAL_UNUSED_ATTRIBUTE;
    1718             : 
    1719           0 : memset(data, 0, sizeof(*data));
    1720           0 : if (der_match_tag(p, len, ASN1_C_CONTEXT, CONS, 0, NULL) == 0) {
    1721             : {
    1722             : size_t negTokenInit_datalen, negTokenInit_oldlen;
    1723             : Der_type negTokenInit_type;
    1724           0 : e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &negTokenInit_type, 0, &negTokenInit_datalen, &l);
    1725           0 : if (e == 0 && negTokenInit_type != CONS) { e = ASN1_BAD_ID; }
    1726           0 : if(e) goto fail;
    1727           0 : p += l; len -= l; ret += l;
    1728           0 : negTokenInit_oldlen = len;
    1729           0 : if (negTokenInit_datalen > len) { e = ASN1_OVERRUN; goto fail; }
    1730           0 : len = negTokenInit_datalen;
    1731           0 : e = decode_NegTokenInitWin(p, len, &(data)->u.negTokenInit, &l);
    1732           0 : if(e) goto fail;
    1733           0 : p += l; len -= l; ret += l;
    1734           0 : len = negTokenInit_oldlen - negTokenInit_datalen;
    1735             : }
    1736           0 : (data)->element = choice_NegotiationTokenWin_negTokenInit;
    1737             : }
    1738             : else {
    1739           0 : e = ASN1_PARSE_ERROR;
    1740           0 : goto fail;
    1741             : }
    1742           0 : if(size) *size = ret;
    1743           0 : return 0;
    1744           0 : fail:
    1745           0 : free_NegotiationTokenWin(data);
    1746           0 : return e;
    1747             : }
    1748             : 
    1749             : void ASN1CALL
    1750           0 : free_NegotiationTokenWin(NegotiationTokenWin *data)
    1751             : {
    1752           0 : switch((data)->element) {
    1753           0 : case choice_NegotiationTokenWin_negTokenInit:
    1754           0 : free_NegTokenInitWin(&(data)->u.negTokenInit);
    1755           0 : break;
    1756             : }
    1757           0 : }
    1758             : 
    1759             : size_t ASN1CALL
    1760           0 : length_NegotiationTokenWin(const NegotiationTokenWin *data)
    1761             : {
    1762           0 : size_t ret = 0;
    1763           0 : switch((data)->element) {
    1764           0 : case choice_NegotiationTokenWin_negTokenInit:
    1765             : {
    1766           0 : size_t Top_oldret = ret;
    1767           0 : ret = 0;
    1768           0 : ret += length_NegTokenInitWin(&(data)->u.negTokenInit);
    1769           0 : ret += 1 + der_length_len (ret);
    1770           0 : ret += Top_oldret;
    1771             : }
    1772           0 : break;
    1773             : }
    1774           0 : return ret;
    1775             : }
    1776             : 
    1777             : int ASN1CALL
    1778           0 : copy_NegotiationTokenWin(const NegotiationTokenWin *from, NegotiationTokenWin *to)
    1779             : {
    1780           0 : memset(to, 0, sizeof(*to));
    1781           0 : (to)->element = (from)->element;
    1782           0 : switch((from)->element) {
    1783           0 : case choice_NegotiationTokenWin_negTokenInit:
    1784           0 : if(copy_NegTokenInitWin(&(from)->u.negTokenInit, &(to)->u.negTokenInit)) goto fail;
    1785           0 : break;
    1786             : }
    1787           0 : return 0;
    1788           0 : fail:
    1789           0 : free_NegotiationTokenWin(to);
    1790           0 : return ENOMEM;
    1791             : }
    1792             : 

Generated by: LCOV version 1.13