1/* Generated from hdb.asn1 */
2/* Do not edit */
3
4#ifndef __hdb_asn1_h__
5#define __hdb_asn1_h__
6
7#include <stddef.h>
8#include <time.h>
9
10#ifndef __asn1_common_definitions__
11#define __asn1_common_definitions__
12
13#ifndef __HEIM_BASE_DATA__
14#define __HEIM_BASE_DATA__ 1
15struct heim_base_data {
16 size_t length;
17 void *data;
18};
19typedef struct heim_base_data heim_octet_string;
20#endif
21
22typedef struct heim_integer {
23 size_t length;
24 void *data;
25 int negative;
26} heim_integer;
27
28typedef char *heim_general_string;
29
30typedef char *heim_utf8_string;
31
32typedef struct heim_base_data heim_printable_string;
33
34typedef struct heim_base_data heim_ia5_string;
35
36typedef struct heim_bmp_string {
37 size_t length;
38 uint16_t *data;
39} heim_bmp_string;
40
41typedef struct heim_universal_string {
42 size_t length;
43 uint32_t *data;
44} heim_universal_string;
45
46typedef char *heim_visible_string;
47
48typedef struct heim_oid {
49 size_t length;
50 unsigned *components;
51} heim_oid;
52
53typedef struct heim_bit_string {
54 size_t length;
55 void *data;
56} heim_bit_string;
57
58typedef struct heim_base_data heim_any;
59typedef struct heim_base_data heim_any_set;
60
61#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \
62 do { \
63 (BL) = length_##T((S)); \
64 (B) = malloc((BL)); \
65 if((B) == NULL) { \
66 (R) = ENOMEM; \
67 } else { \
68 (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
69 (S), (L)); \
70 if((R) != 0) { \
71 free((B)); \
72 (B) = NULL; \
73 } \
74 } \
75 } while (0)
76
77#ifdef _WIN32
78#ifndef ASN1_LIB
79#define ASN1EXP __declspec(dllimport)
80#else
81#define ASN1EXP
82#endif
83#define ASN1CALL __stdcall
84#else
85#define ASN1EXP
86#define ASN1CALL
87#endif
88struct units;
89
90#endif
91
92#include <krb5/krb5_asn1.h>
93enum { HDB_DB_FORMAT = 2 };
94
95enum { hdb_pw_salt = 3 };
96
97enum { hdb_afs3_salt = 10 };
98
99/*
100Salt ::= SEQUENCE {
101 type [0] INTEGER (0..4294967295),
102 salt [1] OCTET STRING,
103 opaque [2] OCTET STRING OPTIONAL,
104}
105*/
106
107typedef struct Salt {
108 unsigned int type;
109 heim_octet_string salt;
110 heim_octet_string *opaque;
111} Salt;
112
113ASN1EXP int ASN1CALL decode_Salt(const unsigned char *, size_t, Salt *, size_t *);
114ASN1EXP int ASN1CALL encode_Salt(unsigned char *, size_t, const Salt *, size_t *);
115ASN1EXP size_t ASN1CALL length_Salt(const Salt *);
116ASN1EXP int ASN1CALL copy_Salt (const Salt *, Salt *);
117ASN1EXP void ASN1CALL free_Salt (Salt *);
118
119
120/*
121Key ::= SEQUENCE {
122 mkvno [0] INTEGER (0..4294967295) OPTIONAL,
123 key [1] EncryptionKey,
124 salt [2] Salt OPTIONAL,
125}
126*/
127
128typedef struct Key {
129 unsigned int *mkvno;
130 EncryptionKey key;
131 Salt *salt;
132} Key;
133
134ASN1EXP int ASN1CALL decode_Key(const unsigned char *, size_t, Key *, size_t *);
135ASN1EXP int ASN1CALL encode_Key(unsigned char *, size_t, const Key *, size_t *);
136ASN1EXP size_t ASN1CALL length_Key(const Key *);
137ASN1EXP int ASN1CALL copy_Key (const Key *, Key *);
138ASN1EXP void ASN1CALL free_Key (Key *);
139
140
141/*
142Event ::= SEQUENCE {
143 time [0] KerberosTime,
144 principal [1] Principal OPTIONAL,
145}
146*/
147
148typedef struct Event {
149 KerberosTime time;
150 Principal *principal;
151} Event;
152
153ASN1EXP int ASN1CALL decode_Event(const unsigned char *, size_t, Event *, size_t *);
154ASN1EXP int ASN1CALL encode_Event(unsigned char *, size_t, const Event *, size_t *);
155ASN1EXP size_t ASN1CALL length_Event(const Event *);
156ASN1EXP int ASN1CALL copy_Event (const Event *, Event *);
157ASN1EXP void ASN1CALL free_Event (Event *);
158
159
160/*
161HDBFlags ::= BIT STRING {
162 initial(0),
163 forwardable(1),
164 proxiable(2),
165 renewable(3),
166 postdate(4),
167 server(5),
168 client(6),
169 invalid(7),
170 require-preauth(8),
171 change-pw(9),
172 require-hwauth(10),
173 ok-as-delegate(11),
174 user-to-user(12),
175 immutable(13),
176 trusted-for-delegation(14),
177 allow-kerberos4(15),
178 allow-digest(16),
179 locked-out(17),
180 require-pwchange(18),
181 do-not-store(31)
182}
183*/
184
185typedef struct HDBFlags {
186 unsigned int initial:1;
187 unsigned int forwardable:1;
188 unsigned int proxiable:1;
189 unsigned int renewable:1;
190 unsigned int postdate:1;
191 unsigned int server:1;
192 unsigned int client:1;
193 unsigned int invalid:1;
194 unsigned int require_preauth:1;
195 unsigned int change_pw:1;
196 unsigned int require_hwauth:1;
197 unsigned int ok_as_delegate:1;
198 unsigned int user_to_user:1;
199 unsigned int immutable:1;
200 unsigned int trusted_for_delegation:1;
201 unsigned int allow_kerberos4:1;
202 unsigned int allow_digest:1;
203 unsigned int locked_out:1;
204 unsigned int require_pwchange:1;
205 unsigned int _unused19:1;
206 unsigned int _unused20:1;
207 unsigned int _unused21:1;
208 unsigned int _unused22:1;
209 unsigned int _unused23:1;
210 unsigned int _unused24:1;
211 unsigned int _unused25:1;
212 unsigned int _unused26:1;
213 unsigned int _unused27:1;
214 unsigned int _unused28:1;
215 unsigned int _unused29:1;
216 unsigned int _unused30:1;
217 unsigned int do_not_store:1;
218} HDBFlags;
219
220
221unsigned HDBFlags2int(HDBFlags);
222HDBFlags int2HDBFlags(unsigned);
223const struct units * asn1_HDBFlags_units(void);
224ASN1EXP int ASN1CALL decode_HDBFlags(const unsigned char *, size_t, HDBFlags *, size_t *);
225ASN1EXP int ASN1CALL encode_HDBFlags(unsigned char *, size_t, const HDBFlags *, size_t *);
226ASN1EXP size_t ASN1CALL length_HDBFlags(const HDBFlags *);
227ASN1EXP int ASN1CALL copy_HDBFlags (const HDBFlags *, HDBFlags *);
228ASN1EXP void ASN1CALL free_HDBFlags (HDBFlags *);
229
230
231/*
232GENERATION ::= SEQUENCE {
233 time [0] KerberosTime,
234 usec [1] INTEGER (0..4294967295),
235 gen [2] INTEGER (0..4294967295),
236}
237*/
238
239typedef struct GENERATION {
240 KerberosTime time;
241 unsigned int usec;
242 unsigned int gen;
243} GENERATION;
244
245ASN1EXP int ASN1CALL decode_GENERATION(const unsigned char *, size_t, GENERATION *, size_t *);
246ASN1EXP int ASN1CALL encode_GENERATION(unsigned char *, size_t, const GENERATION *, size_t *);
247ASN1EXP size_t ASN1CALL length_GENERATION(const GENERATION *);
248ASN1EXP int ASN1CALL copy_GENERATION (const GENERATION *, GENERATION *);
249ASN1EXP void ASN1CALL free_GENERATION (GENERATION *);
250
251
252/*
253HDB-Ext-PKINIT-acl ::= SEQUENCE OF SEQUENCE {
254 subject [0] UTF8String,
255 issuer [1] UTF8String OPTIONAL,
256 anchor [2] UTF8String OPTIONAL,
257}
258*/
259
260typedef struct HDB_Ext_PKINIT_acl {
261 unsigned int len;
262 struct HDB_Ext_PKINIT_acl_val {
263 heim_utf8_string subject;
264 heim_utf8_string *issuer;
265 heim_utf8_string *anchor;
266 } *val;
267} HDB_Ext_PKINIT_acl;
268
269ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_acl(const unsigned char *, size_t, HDB_Ext_PKINIT_acl *, size_t *);
270ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_acl(unsigned char *, size_t, const HDB_Ext_PKINIT_acl *, size_t *);
271ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_acl(const HDB_Ext_PKINIT_acl *);
272ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_acl (const HDB_Ext_PKINIT_acl *, HDB_Ext_PKINIT_acl *);
273ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_acl (HDB_Ext_PKINIT_acl *);
274
275
276/*
277HDB-Ext-PKINIT-hash ::= SEQUENCE OF SEQUENCE {
278 digest-type [0] OBJECT IDENTIFIER,
279 digest [1] OCTET STRING,
280}
281*/
282
283typedef struct HDB_Ext_PKINIT_hash {
284 unsigned int len;
285 struct HDB_Ext_PKINIT_hash_val {
286 heim_oid digest_type;
287 heim_octet_string digest;
288 } *val;
289} HDB_Ext_PKINIT_hash;
290
291ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_hash(const unsigned char *, size_t, HDB_Ext_PKINIT_hash *, size_t *);
292ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_hash(unsigned char *, size_t, const HDB_Ext_PKINIT_hash *, size_t *);
293ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_hash(const HDB_Ext_PKINIT_hash *);
294ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_hash (const HDB_Ext_PKINIT_hash *, HDB_Ext_PKINIT_hash *);
295ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_hash (HDB_Ext_PKINIT_hash *);
296
297
298/*
299HDB-Ext-PKINIT-cert ::= SEQUENCE OF SEQUENCE {
300 cert [0] OCTET STRING,
301}
302*/
303
304typedef struct HDB_Ext_PKINIT_cert {
305 unsigned int len;
306 struct HDB_Ext_PKINIT_cert_val {
307 heim_octet_string cert;
308 } *val;
309} HDB_Ext_PKINIT_cert;
310
311ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_cert(const unsigned char *, size_t, HDB_Ext_PKINIT_cert *, size_t *);
312ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_cert(unsigned char *, size_t, const HDB_Ext_PKINIT_cert *, size_t *);
313ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_cert(const HDB_Ext_PKINIT_cert *);
314ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_cert (const HDB_Ext_PKINIT_cert *, HDB_Ext_PKINIT_cert *);
315ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_cert (HDB_Ext_PKINIT_cert *);
316
317
318/*
319HDB-Ext-Constrained-delegation-acl ::= SEQUENCE OF Principal
320*/
321
322typedef struct HDB_Ext_Constrained_delegation_acl {
323 unsigned int len;
324 Principal *val;
325} HDB_Ext_Constrained_delegation_acl;
326
327ASN1EXP int ASN1CALL decode_HDB_Ext_Constrained_delegation_acl(const unsigned char *, size_t, HDB_Ext_Constrained_delegation_acl *, size_t *);
328ASN1EXP int ASN1CALL encode_HDB_Ext_Constrained_delegation_acl(unsigned char *, size_t, const HDB_Ext_Constrained_delegation_acl *, size_t *);
329ASN1EXP size_t ASN1CALL length_HDB_Ext_Constrained_delegation_acl(const HDB_Ext_Constrained_delegation_acl *);
330ASN1EXP int ASN1CALL copy_HDB_Ext_Constrained_delegation_acl (const HDB_Ext_Constrained_delegation_acl *, HDB_Ext_Constrained_delegation_acl *);
331ASN1EXP void ASN1CALL free_HDB_Ext_Constrained_delegation_acl (HDB_Ext_Constrained_delegation_acl *);
332
333
334/*
335HDB-Ext-Lan-Manager-OWF ::= OCTET STRING
336*/
337
338typedef heim_octet_string HDB_Ext_Lan_Manager_OWF;
339
340ASN1EXP int ASN1CALL decode_HDB_Ext_Lan_Manager_OWF(const unsigned char *, size_t, HDB_Ext_Lan_Manager_OWF *, size_t *);
341ASN1EXP int ASN1CALL encode_HDB_Ext_Lan_Manager_OWF(unsigned char *, size_t, const HDB_Ext_Lan_Manager_OWF *, size_t *);
342ASN1EXP size_t ASN1CALL length_HDB_Ext_Lan_Manager_OWF(const HDB_Ext_Lan_Manager_OWF *);
343ASN1EXP int ASN1CALL copy_HDB_Ext_Lan_Manager_OWF (const HDB_Ext_Lan_Manager_OWF *, HDB_Ext_Lan_Manager_OWF *);
344ASN1EXP void ASN1CALL free_HDB_Ext_Lan_Manager_OWF (HDB_Ext_Lan_Manager_OWF *);
345
346
347/*
348HDB-Ext-Password ::= SEQUENCE {
349 mkvno [0] INTEGER (0..4294967295) OPTIONAL,
350 password OCTET STRING,
351}
352*/
353
354typedef struct HDB_Ext_Password {
355 unsigned int *mkvno;
356 heim_octet_string password;
357} HDB_Ext_Password;
358
359ASN1EXP int ASN1CALL decode_HDB_Ext_Password(const unsigned char *, size_t, HDB_Ext_Password *, size_t *);
360ASN1EXP int ASN1CALL encode_HDB_Ext_Password(unsigned char *, size_t, const HDB_Ext_Password *, size_t *);
361ASN1EXP size_t ASN1CALL length_HDB_Ext_Password(const HDB_Ext_Password *);
362ASN1EXP int ASN1CALL copy_HDB_Ext_Password (const HDB_Ext_Password *, HDB_Ext_Password *);
363ASN1EXP void ASN1CALL free_HDB_Ext_Password (HDB_Ext_Password *);
364
365
366/*
367HDB-Ext-Aliases ::= SEQUENCE {
368 case-insensitive [0] BOOLEAN,
369 aliases [1] SEQUENCE OF Principal,
370}
371*/
372
373typedef struct HDB_Ext_Aliases {
374 int case_insensitive;
375 struct HDB_Ext_Aliases_aliases {
376 unsigned int len;
377 Principal *val;
378 } aliases;
379} HDB_Ext_Aliases;
380
381ASN1EXP int ASN1CALL decode_HDB_Ext_Aliases(const unsigned char *, size_t, HDB_Ext_Aliases *, size_t *);
382ASN1EXP int ASN1CALL encode_HDB_Ext_Aliases(unsigned char *, size_t, const HDB_Ext_Aliases *, size_t *);
383ASN1EXP size_t ASN1CALL length_HDB_Ext_Aliases(const HDB_Ext_Aliases *);
384ASN1EXP int ASN1CALL copy_HDB_Ext_Aliases (const HDB_Ext_Aliases *, HDB_Ext_Aliases *);
385ASN1EXP void ASN1CALL free_HDB_Ext_Aliases (HDB_Ext_Aliases *);
386
387
388/*
389Keys ::= SEQUENCE OF Key
390*/
391
392typedef struct Keys {
393 unsigned int len;
394 Key *val;
395} Keys;
396
397ASN1EXP int ASN1CALL add_Keys (Keys *, const Key *);
398ASN1EXP int ASN1CALL remove_Keys (Keys *, unsigned int);
399ASN1EXP int ASN1CALL decode_Keys(const unsigned char *, size_t, Keys *, size_t *);
400ASN1EXP int ASN1CALL encode_Keys(unsigned char *, size_t, const Keys *, size_t *);
401ASN1EXP size_t ASN1CALL length_Keys(const Keys *);
402ASN1EXP int ASN1CALL copy_Keys (const Keys *, Keys *);
403ASN1EXP void ASN1CALL free_Keys (Keys *);
404
405
406/*
407hdb_keyset ::= SEQUENCE {
408 kvno [0] INTEGER (0..4294967295),
409 keys [1] Keys,
410 set-time [2] KerberosTime OPTIONAL,
411 ...,
412}
413*/
414
415typedef struct hdb_keyset {
416 unsigned int kvno;
417 Keys keys;
418 KerberosTime *set_time;
419} hdb_keyset;
420
421ASN1EXP int ASN1CALL decode_hdb_keyset(const unsigned char *, size_t, hdb_keyset *, size_t *);
422ASN1EXP int ASN1CALL encode_hdb_keyset(unsigned char *, size_t, const hdb_keyset *, size_t *);
423ASN1EXP size_t ASN1CALL length_hdb_keyset(const hdb_keyset *);
424ASN1EXP int ASN1CALL copy_hdb_keyset (const hdb_keyset *, hdb_keyset *);
425ASN1EXP void ASN1CALL free_hdb_keyset (hdb_keyset *);
426
427
428/*
429HDB-Ext-KeySet ::= SEQUENCE OF hdb_keyset
430*/
431
432typedef struct HDB_Ext_KeySet {
433 unsigned int len;
434 hdb_keyset *val;
435} HDB_Ext_KeySet;
436
437ASN1EXP int ASN1CALL add_HDB_Ext_KeySet (HDB_Ext_KeySet *, const hdb_keyset *);
438ASN1EXP int ASN1CALL remove_HDB_Ext_KeySet (HDB_Ext_KeySet *, unsigned int);
439ASN1EXP int ASN1CALL decode_HDB_Ext_KeySet(const unsigned char *, size_t, HDB_Ext_KeySet *, size_t *);
440ASN1EXP int ASN1CALL encode_HDB_Ext_KeySet(unsigned char *, size_t, const HDB_Ext_KeySet *, size_t *);
441ASN1EXP size_t ASN1CALL length_HDB_Ext_KeySet(const HDB_Ext_KeySet *);
442ASN1EXP int ASN1CALL copy_HDB_Ext_KeySet (const HDB_Ext_KeySet *, HDB_Ext_KeySet *);
443ASN1EXP void ASN1CALL free_HDB_Ext_KeySet (HDB_Ext_KeySet *);
444
445
446/*
447HDB-extension ::= SEQUENCE {
448 mandatory [0] BOOLEAN,
449 data [1] CHOICE {
450 pkinit-acl [0] HDB-Ext-PKINIT-acl,
451 pkinit-cert-hash [1] HDB-Ext-PKINIT-hash,
452 allowed-to-delegate-to [2] HDB-Ext-Constrained-delegation-acl,
453 lm-owf [4] HDB-Ext-Lan-Manager-OWF,
454 password [5] HDB-Ext-Password,
455 aliases [6] HDB-Ext-Aliases,
456 last-pw-change [7] KerberosTime,
457 pkinit-cert [8] HDB-Ext-PKINIT-cert,
458 hist-keys [9] HDB-Ext-KeySet,
459 hist-kvno-diff-clnt [10] INTEGER (0..4294967295),
460 hist-kvno-diff-svc [11] INTEGER (0..4294967295),
461 policy [12] UTF8String,
462 principal-id [13] INTEGER (-9223372036854775808..9223372036854775807),
463 ...,
464 },
465 ...,
466}
467*/
468
469typedef struct HDB_extension {
470 int mandatory;
471 struct HDB_extension_data {
472 enum HDB_extension_data_enum {
473 choice_HDB_extension_data_asn1_ellipsis = 0,
474 choice_HDB_extension_data_pkinit_acl,
475 choice_HDB_extension_data_pkinit_cert_hash,
476 choice_HDB_extension_data_allowed_to_delegate_to,
477 choice_HDB_extension_data_lm_owf,
478 choice_HDB_extension_data_password,
479 choice_HDB_extension_data_aliases,
480 choice_HDB_extension_data_last_pw_change,
481 choice_HDB_extension_data_pkinit_cert,
482 choice_HDB_extension_data_hist_keys,
483 choice_HDB_extension_data_hist_kvno_diff_clnt,
484 choice_HDB_extension_data_hist_kvno_diff_svc,
485 choice_HDB_extension_data_policy,
486 choice_HDB_extension_data_principal_id
487 /* ... */
488 } element;
489 union {
490 HDB_Ext_PKINIT_acl pkinit_acl;
491 HDB_Ext_PKINIT_hash pkinit_cert_hash;
492 HDB_Ext_Constrained_delegation_acl allowed_to_delegate_to;
493 HDB_Ext_Lan_Manager_OWF lm_owf;
494 HDB_Ext_Password password;
495 HDB_Ext_Aliases aliases;
496 KerberosTime last_pw_change;
497 HDB_Ext_PKINIT_cert pkinit_cert;
498 HDB_Ext_KeySet hist_keys;
499 unsigned int hist_kvno_diff_clnt;
500 unsigned int hist_kvno_diff_svc;
501 heim_utf8_string policy;
502 int64_t principal_id;
503 heim_octet_string asn1_ellipsis;
504 } u;
505 } data;
506} HDB_extension;
507
508ASN1EXP int ASN1CALL decode_HDB_extension(const unsigned char *, size_t, HDB_extension *, size_t *);
509ASN1EXP int ASN1CALL encode_HDB_extension(unsigned char *, size_t, const HDB_extension *, size_t *);
510ASN1EXP size_t ASN1CALL length_HDB_extension(const HDB_extension *);
511ASN1EXP int ASN1CALL copy_HDB_extension (const HDB_extension *, HDB_extension *);
512ASN1EXP void ASN1CALL free_HDB_extension (HDB_extension *);
513
514
515/*
516HDB-extensions ::= SEQUENCE OF HDB-extension
517*/
518
519typedef struct HDB_extensions {
520 unsigned int len;
521 HDB_extension *val;
522} HDB_extensions;
523
524ASN1EXP int ASN1CALL decode_HDB_extensions(const unsigned char *, size_t, HDB_extensions *, size_t *);
525ASN1EXP int ASN1CALL encode_HDB_extensions(unsigned char *, size_t, const HDB_extensions *, size_t *);
526ASN1EXP size_t ASN1CALL length_HDB_extensions(const HDB_extensions *);
527ASN1EXP int ASN1CALL copy_HDB_extensions (const HDB_extensions *, HDB_extensions *);
528ASN1EXP void ASN1CALL free_HDB_extensions (HDB_extensions *);
529
530
531/*
532hdb_entry ::= SEQUENCE {
533 principal [0] Principal OPTIONAL,
534 kvno [1] INTEGER (0..4294967295),
535 keys [2] Keys,
536 created-by [3] Event,
537 modified-by [4] Event OPTIONAL,
538 valid-start [5] KerberosTime OPTIONAL,
539 valid-end [6] KerberosTime OPTIONAL,
540 pw-end [7] KerberosTime OPTIONAL,
541 max-life [8] INTEGER (0..4294967295) OPTIONAL,
542 max-renew [9] INTEGER (0..4294967295) OPTIONAL,
543 flags [10] HDBFlags,
544 etypes [11] SEQUENCE OF INTEGER (0..4294967295) OPTIONAL,
545 generation [12] GENERATION OPTIONAL,
546 extensions [13] HDB-extensions OPTIONAL,
547}
548*/
549
550typedef struct hdb_entry {
551 Principal *principal;
552 unsigned int kvno;
553 Keys keys;
554 Event created_by;
555 Event *modified_by;
556 KerberosTime *valid_start;
557 KerberosTime *valid_end;
558 KerberosTime *pw_end;
559 unsigned int *max_life;
560 unsigned int *max_renew;
561 HDBFlags flags;
562 struct hdb_entry_etypes {
563 unsigned int len;
564 unsigned int *val;
565 } *etypes;
566 GENERATION *generation;
567 HDB_extensions *extensions;
568} hdb_entry;
569
570ASN1EXP int ASN1CALL decode_hdb_entry(const unsigned char *, size_t, hdb_entry *, size_t *);
571ASN1EXP int ASN1CALL encode_hdb_entry(unsigned char *, size_t, const hdb_entry *, size_t *);
572ASN1EXP size_t ASN1CALL length_hdb_entry(const hdb_entry *);
573ASN1EXP int ASN1CALL copy_hdb_entry (const hdb_entry *, hdb_entry *);
574ASN1EXP void ASN1CALL free_hdb_entry (hdb_entry *);
575
576
577/*
578hdb_entry_alias ::= [APPLICATION 0] SEQUENCE {
579 principal [0] Principal OPTIONAL,
580}
581*/
582
583typedef struct hdb_entry_alias {
584 Principal *principal;
585} hdb_entry_alias;
586
587ASN1EXP int ASN1CALL decode_hdb_entry_alias(const unsigned char *, size_t, hdb_entry_alias *, size_t *);
588ASN1EXP int ASN1CALL encode_hdb_entry_alias(unsigned char *, size_t, const hdb_entry_alias *, size_t *);
589ASN1EXP size_t ASN1CALL length_hdb_entry_alias(const hdb_entry_alias *);
590ASN1EXP int ASN1CALL copy_hdb_entry_alias (const hdb_entry_alias *, hdb_entry_alias *);
591ASN1EXP void ASN1CALL free_hdb_entry_alias (hdb_entry_alias *);
592
593
594#endif /* __hdb_asn1_h__ */
595