-
Notifications
You must be signed in to change notification settings - Fork 286
/
asn1.d
1429 lines (1246 loc) · 53.7 KB
/
asn1.d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* crypto/asn1/asn1.h */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
module deimos.openssl.asn1;
import deimos.openssl._d_util;
import deimos.openssl.asn1t; // Needed for ASN1_ITEM_st.
import core.stdc.time;
public import deimos.openssl.e_os2;
version(OPENSSL_NO_BIO) {} else {
public import deimos.openssl.bio;
}
public import deimos.openssl.stack;
public import deimos.openssl.safestack;
public import deimos.openssl.symhacks;
public import deimos.openssl.ossl_typ;
version(OPENSSL_NO_DEPRECATED) {} else {
public import deimos.openssl.bn;
}
extern (C):
nothrow:
enum V_ASN1_UNIVERSAL = 0x00;
enum V_ASN1_APPLICATION = 0x40;
enum V_ASN1_CONTEXT_SPECIFIC = 0x80;
enum V_ASN1_PRIVATE = 0xc0;
enum V_ASN1_CONSTRUCTED = 0x20;
enum V_ASN1_PRIMITIVE_TAG = 0x1f;
enum V_ASN1_PRIMATIVE_TAG = 0x1f;
enum V_ASN1_APP_CHOOSE = -2; /* let the recipient choose */
enum V_ASN1_OTHER = -3; /* used in ASN1_TYPE */
enum V_ASN1_ANY = -4; /* used in ASN1 template code */
enum V_ASN1_NEG = 0x100; /* negative flag */
enum V_ASN1_UNDEF = -1;
enum V_ASN1_EOC = 0;
enum V_ASN1_BOOLEAN = 1; /**/
enum V_ASN1_INTEGER = 2;
enum V_ASN1_NEG_INTEGER = (2 | V_ASN1_NEG);
enum V_ASN1_BIT_STRING = 3;
enum V_ASN1_OCTET_STRING = 4;
enum V_ASN1_NULL = 5;
enum V_ASN1_OBJECT = 6;
enum V_ASN1_OBJECT_DESCRIPTOR = 7;
enum V_ASN1_EXTERNAL = 8;
enum V_ASN1_REAL = 9;
enum V_ASN1_ENUMERATED = 10;
enum V_ASN1_NEG_ENUMERATED = (10 | V_ASN1_NEG);
enum V_ASN1_UTF8STRING = 12;
enum V_ASN1_SEQUENCE = 16;
enum V_ASN1_SET = 17;
enum V_ASN1_NUMERICSTRING = 18; /**/
enum V_ASN1_PRINTABLESTRING = 19;
enum V_ASN1_T61STRING = 20;
enum V_ASN1_TELETEXSTRING = 20; /* alias */
enum V_ASN1_VIDEOTEXSTRING = 21; /**/
enum V_ASN1_IA5STRING = 22;
enum V_ASN1_UTCTIME = 23;
enum V_ASN1_GENERALIZEDTIME = 24; /**/
enum V_ASN1_GRAPHICSTRING = 25; /**/
enum V_ASN1_ISO64STRING = 26; /**/
enum V_ASN1_VISIBLESTRING = 26; /* alias */
enum V_ASN1_GENERALSTRING = 27; /**/
enum V_ASN1_UNIVERSALSTRING = 28; /**/
enum V_ASN1_BMPSTRING = 30;
/* For use with d2i_ASN1_type_bytes() */
enum B_ASN1_NUMERICSTRING = 0x0001;
enum B_ASN1_PRINTABLESTRING = 0x0002;
enum B_ASN1_T61STRING = 0x0004;
enum B_ASN1_TELETEXSTRING = 0x0004;
enum B_ASN1_VIDEOTEXSTRING = 0x0008;
enum B_ASN1_IA5STRING = 0x0010;
enum B_ASN1_GRAPHICSTRING = 0x0020;
enum B_ASN1_ISO64STRING = 0x0040;
enum B_ASN1_VISIBLESTRING = 0x0040;
enum B_ASN1_GENERALSTRING = 0x0080;
enum B_ASN1_UNIVERSALSTRING = 0x0100;
enum B_ASN1_OCTET_STRING = 0x0200;
enum B_ASN1_BIT_STRING = 0x0400;
enum B_ASN1_BMPSTRING = 0x0800;
enum B_ASN1_UNKNOWN = 0x1000;
enum B_ASN1_UTF8STRING = 0x2000;
enum B_ASN1_UTCTIME = 0x4000;
enum B_ASN1_GENERALIZEDTIME = 0x8000;
enum B_ASN1_SEQUENCE = 0x10000;
/* For use with ASN1_mbstring_copy() */
enum MBSTRING_FLAG = 0x1000;
enum MBSTRING_UTF8 = (MBSTRING_FLAG);
enum MBSTRING_ASC = (MBSTRING_FLAG|1);
enum MBSTRING_BMP = (MBSTRING_FLAG|2);
enum MBSTRING_UNIV = (MBSTRING_FLAG|4);
enum SMIME_OLDMIME = 0x400;
enum SMIME_CRLFEOL = 0x800;
enum SMIME_STREAM = 0x1000;
/+mixin DECLARE_STACK_OF!(X509_ALGOR);+/
mixin template DECLARE_ASN1_SET_OF(type) {} /* filled in by mkstack.pl */
mixin template IMPLEMENT_ASN1_SET_OF(type) {} /* nothing, no longer needed */
/* We MUST make sure that, except for constness, asn1_ctx_st and
asn1_const_ctx are exactly the same. Fortunately, as soon as
the old ASN1 parsing macros are gone, we can throw this away
as well... */
struct asn1_ctx_st {
ubyte* p;/* work char pointer */
int eos; /* end of sequence read for indefinite encoding */
int error; /* error code to use when returning an error */
int inf; /* constructed if 0x20, indefinite is 0x21 */
int tag; /* tag from last 'get object' */
int xclass; /* class from last 'get object' */
c_long slen; /* length of last 'get object' */
ubyte* max; /* largest value of p allowed */
ubyte* q;/* temporary variable */
ubyte** pp;/* variable */
int line; /* used in error processing */
}
alias asn1_ctx_st ASN1_CTX;
struct asn1_const_ctx_st {
const(ubyte)* p;/* work char pointer */
int eos; /* end of sequence read for indefinite encoding */
int error; /* error code to use when returning an error */
int inf; /* constructed if 0x20, indefinite is 0x21 */
int tag; /* tag from last 'get object' */
int xclass; /* class from last 'get object' */
c_long slen; /* length of last 'get object' */
const(ubyte)* max; /* largest value of p allowed */
const(ubyte)* q;/* temporary variable */
const(ubyte)** pp;/* variable */
int line; /* used in error processing */
}
alias asn1_const_ctx_st ASN1_const_CTX;
/* These are used internally in the ASN1_OBJECT to keep track of
* whether the names and data need to be free()ed */
enum ASN1_OBJECT_FLAG_DYNAMIC = 0x01; /* internal use */
enum ASN1_OBJECT_FLAG_CRITICAL = 0x02; /* critical x509v3 object id */
enum ASN1_OBJECT_FLAG_DYNAMIC_STRINGS = 0x04; /* internal use */
enum ASN1_OBJECT_FLAG_DYNAMIC_DATA = 0x08; /* internal use */
struct asn1_object_st {
const(char)* sn,ln;
int nid;
int length;
const(ubyte)* data; /* data remains const after init */
int flags; /* Should we free this one */
}
alias asn1_object_st ASN1_OBJECT;
enum ASN1_STRING_FLAG_BITS_LEFT = 0x08; /* Set if 0x07 has bits left value */
/* This indicates that the ASN1_STRING is not a real value but just a place
* holder for the location where indefinite length constructed data should
* be inserted in the memory buffer
*/
enum ASN1_STRING_FLAG_NDEF = 0x010;
/* This flag is used by the CMS code to indicate that a string is not
* complete and is a place holder for content when it had all been
* accessed. The flag will be reset when content has been written to it.
*/
enum ASN1_STRING_FLAG_CONT = 0x020;
/* This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING
* type.
*/
enum ASN1_STRING_FLAG_MSTRING = 0x040;
/* This is the base type that holds just about everything :-) */
struct asn1_string_st {
int length;
int type;
ubyte* data;
/* The value of the following field depends on the type being
* held. It is mostly being used for BIT_STRING so if the
* input data has a non-zero 'unused bits' value, it will be
* handled correctly */
c_long flags;
}
alias asn1_string_st ASN1_STRING;
/* ASN1_ENCODING structure: this is used to save the received
* encoding of an ASN1 type. This is useful to get round
* problems with invalid encodings which can break signatures.
*/
struct ASN1_ENCODING_st {
ubyte* enc; /* DER encoding */
c_long len; /* Length of encoding */
int modified; /* set to 1 if 'enc' is invalid */
}
alias ASN1_ENCODING_st ASN1_ENCODING;
/* Used with ASN1 LONG type: if a c_long is set to this it is omitted */
enum ASN1_LONG_UNDEF = 0x7fffffff;
enum STABLE_FLAGS_MALLOC = 0x01;
enum STABLE_NO_MASK = 0x02;
enum DIRSTRING_TYPE = (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING);
enum PKCS9STRING_TYPE = (DIRSTRING_TYPE|B_ASN1_IA5STRING);
struct asn1_string_table_st {
int nid;
c_long minsize;
c_long maxsize;
c_ulong mask;
c_ulong flags;
}
alias asn1_string_table_st ASN1_STRING_TABLE;
/+mixin DECLARE_STACK_OF!(ASN1_STRING_TABLE);+/
/* size limits: this stuff is taken straight from RFC2459 */
enum ub_name = 32768;
enum ub_common_name = 64;
enum ub_locality_name = 128;
enum ub_state_name = 128;
enum ub_organization_name = 64;
enum ub_organization_unit_name = 64;
enum ub_title = 64;
enum ub_email_address = 128;
/* Declarations for template structures: for full definitions
* see asn1t.h
*/
alias ASN1_TEMPLATE_st ASN1_TEMPLATE;
alias ASN1_ITEM_st ASN1_ITEM;
import deimos.openssl.asn1t; /*struct ASN1_TLC_st;*/
alias ASN1_TLC_st ASN1_TLC;
/* This is just an opaque pointer */
struct ASN1_VALUE_st;
alias ASN1_VALUE_st ASN1_VALUE;
/* Declare ASN1 functions: the implement macro in in asn1t.h */
// Need to use string mixins here to avoid DMD mangling extern(C) symbol names.
template DECLARE_ASN1_FUNCTIONS(string type) {
enum DECLARE_ASN1_FUNCTIONS = DECLARE_ASN1_FUNCTIONS_name!(type, type);
}
template DECLARE_ASN1_ALLOC_FUNCTIONS(string type) {
enum DECLARE_ASN1_ALLOC_FUNCTIONS =
DECLARE_ASN1_ALLOC_FUNCTIONS_name!(type, type);
}
template DECLARE_ASN1_FUNCTIONS_name(string type, string name) {
enum DECLARE_ASN1_FUNCTIONS_name =
DECLARE_ASN1_ALLOC_FUNCTIONS_name!(type, name) ~
DECLARE_ASN1_ENCODE_FUNCTIONS!(type, name, name);
}
template DECLARE_ASN1_FUNCTIONS_fname(string type, string itname, string name) {
enum DECLARE_ASN1_FUNCTIONS_fname =
DECLARE_ASN1_ALLOC_FUNCTIONS_name!(type, name) ~
DECLARE_ASN1_ENCODE_FUNCTIONS!(type, itname, name);
}
template DECLARE_ASN1_ENCODE_FUNCTIONS(string type, string itname, string name) {
enum DECLARE_ASN1_ENCODE_FUNCTIONS = "
" ~ type ~ "* d2i_" ~ name ~ "(" ~ type ~ "** a, const(ubyte)** in_, c_long len);
int i2d_" ~ name ~ "(" ~ type ~ "* a, ubyte** out_);
" ~ DECLARE_ASN1_ITEM!itname;
}
template DECLARE_ASN1_ENCODE_FUNCTIONS_const(string type, string name) {
enum DECLARE_ASN1_ENCODE_FUNCTIONS_const = "
" ~ type ~ "* d2i_" ~ name ~ "(" ~ type ~ "** a, const(ubyte)** in_, c_long len);
int i2d_" ~ name ~ "(const(" ~ type ~ ")* a, ubyte** out_);
" ~ DECLARE_ASN1_ITEM!name;
}
template DECLARE_ASN1_NDEF_FUNCTION(string name) {
enum DECLARE_ASN1_NDEF_FUNCTION = "
int i2d_" ~ name ~ "_NDEF(" ~ name ~ "* a, ubyte** out_);
";
}
template DECLARE_ASN1_FUNCTIONS_const(string name) {
enum DECLARE_ASN1_FUNCTIONS_const =
DECLARE_ASN1_ALLOC_FUNCTIONS!name ~
DECLARE_ASN1_ENCODE_FUNCTIONS_const!(name, name);
}
template DECLARE_ASN1_ALLOC_FUNCTIONS_name(string type, string name) {
enum DECLARE_ASN1_ALLOC_FUNCTIONS_name = "
extern(C) " ~ type ~ "* " ~ name ~ "_new();
extern(C) void " ~ name ~ "_free(" ~ type ~ "* a);
";
}
template DECLARE_ASN1_PRINT_FUNCTION(string stname) {
enum DECLARE_ASN1_PRINT_FUNCTION =
DECLARE_ASN1_PRINT_FUNCTION_fname!(stname, stname);
}
template DECLARE_ASN1_PRINT_FUNCTION_fname(string stname, string fname) {
enum DECLARE_ASN1_PRINT_FUNCTION_fname = "
int " ~ fname ~ "_print_ctx(BIO* out_, " ~ stname ~ "* x, int indent,
const(ASN1_PCTX)* pctx);
";
}
template D2I_OF(type) {
alias ExternC!(type* function(type**, const(ubyte)**, c_long)) D2I_OF;
}
template I2D_OF(type) {
alias ExternC!(int function(type*, ubyte**)) I2D_OF;
}
template I2D_OF_const(type) {
alias ExternC!(int function(const(type)*, ubyte**)) I2D_OF_const;
}
d2i_of_void* CHECKED_D2I_OF(type)(D2I_OF!type d2i) {
return cast(d2i_of_void*) (1 ? d2i : null);
}
i2d_of_void* CHECKED_I2D_OF(type)(I2D_OF!type i2d) {
return cast(i2d_of_void*) (1 ? i2d : null);
}
ExternC!(type* function()) CHECKED_NEW_OF(type)(ExternC!(type* function()) xnew) {
return typeof(return)(1 ? xnew : null);
}
void* CHECKED_PTR_OF(type)(type* p) {
return cast(void*)(1 ? p : null);
}
void* CHECKED_PPTR_OF(type)(type** p) {
return cast(void**)(1 ? p : null);
}
template TYPEDEF_D2I_OF(string type) {
enum TYPEDEF_D2I_OF = "alias typeof(D2I_OF!(" ~ type ~ ").init) d2i_of_" ~ type ~ ";";
}
template TYPEDEF_I2D_OF(string type) {
enum TYPEDEF_I2D_OF = "alias typeof(I2D_OF!(" ~ type ~ ").init) i2d_of_" ~ type ~ ";";
}
template TYPEDEF_D2I2D_OF(string type) {
enum TYPEDEF_D2I2D_OF = TYPEDEF_D2I_OF!type ~ TYPEDEF_I2D_OF!type;
}
// Probably due to a DMD @@BUG@@, the types are not available to all modules
// if the mixin is used.
// mixin(TYPEDEF_D2I2D_OF!"void");
alias typeof(*(D2I_OF!void).init) d2i_of_void;
alias typeof(*(I2D_OF!void).init) i2d_of_void;
/* The following macros and typedefs allow an ASN1_ITEM
* to be embedded in a structure and referenced. Since
* the ASN1_ITEM pointers need to be globally accessible
* (possibly from shared libraries) they may exist in
* different forms. On platforms that support it the
* ASN1_ITEM structure itself will be globally exported.
* Other platforms will export a function that returns
* an ASN1_ITEM pointer.
*
* To handle both cases transparently the macros below
* should be used instead of hard coding an ASN1_ITEM
* pointer in a structure.
*
* The structure will look like this:
*
* struct SOMETHING_st {
* ...
* ASN1_ITEM_EXP* iptr;
* ...
* }
alias SOMETHING_st SOMETHING;
*
* It would be initialised as e.g.:
*
* SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...};
*
* and the actual pointer extracted with:
*
* const(ASN1_ITEM)* it = ASN1_ITEM_ptr(somevar.iptr);
*
* Finally an ASN1_ITEM pointer can be extracted from an
* appropriate reference with: ASN1_ITEM_rptr(X509). This
* would be used when a function takes an ASN1_ITEM* argument.
*
*/
version (OPENSSL_EXPORT_VAR_AS_FUNCTION) {
/* Platforms that can't easily handle shared global variables are declared
* as functions returning ASN1_ITEM pointers.
*/
/* ASN1_ITEM pointer exported type */
alias const(ASN1_ITEM)* ASN1_ITEM_EXP;
/* Macro to obtain ASN1_ITEM pointer from exported type */
template ASN1_ITEM_ptr(string iptr) {
enum ASN1_ITEM_ptr = "(" ~ iptr ~ ")()";
}
/* Macro to include ASN1_ITEM pointer from base type */
template ASN1_ITEM_ref(string iptr) {
enum ASN1_ITEM_ref = "(" ~ iptr ~ "_it)";
}
template ASN1_ITEM_rptr(string ref_) {
enum ASN1_ITEM_rptr = "(" ~ ref_ ~ "_it())";
}
template DECLARE_ASN1_ITEM(string name) {
enum DECLARE_ASN1_ITEM = "extern(C) const(ASN1_ITEM)* " ~ name ~ "_it();";
}
} else {
/* ASN1_ITEM pointer exported type */
alias const(ASN1_ITEM) ASN1_ITEM_EXP;
/* Macro to obtain ASN1_ITEM pointer from exported type */
template ASN1_ITEM_ptr(string iptr) {
enum ASN1_ITEM_ptr = iptr;
}
/* Macro to include ASN1_ITEM pointer from base type */
template ASN1_ITEM_ref(string iptr) {
enum ASN1_ITEM_ref = "(&(" ~ iptr ~ "_it))";
}
template ASN1_ITEM_rptr(string ref_) {
enum ASN1_ITEM_rptr = "(&(" ~ ref_ ~ "_it))";
}
template DECLARE_ASN1_ITEM(string name) {
enum DECLARE_ASN1_ITEM = "extern const(ASN1_ITEM) " ~ name ~ "_it;";
}
}
/* Parameters used by ASN1_STRING_print_ex() */
/* These determine which characters to escape:
* RFC2253 special characters, control characters and
* MSB set characters
*/
enum ASN1_STRFLGS_ESC_2253 = 1;
enum ASN1_STRFLGS_ESC_CTRL = 2;
enum ASN1_STRFLGS_ESC_MSB = 4;
/* This flag determines how we do escaping: normally
* RC2253 backslash only, set this to use backslash and
* quote.
*/
enum ASN1_STRFLGS_ESC_QUOTE = 8;
/* These three flags are internal use only. */
/* Character is a valid PrintableString character */
enum CHARTYPE_PRINTABLESTRING = 0x10;
/* Character needs escaping if it is the first character */
enum CHARTYPE_FIRST_ESC_2253 = 0x20;
/* Character needs escaping if it is the last character */
enum CHARTYPE_LAST_ESC_2253 = 0x40;
/* NB the internal flags are safely reused below by flags
* handled at the top level.
*/
/* If this is set we convert all character strings
* to UTF8 first
*/
enum ASN1_STRFLGS_UTF8_CONVERT = 0x10;
/* If this is set we don't attempt to interpret content:
* just assume all strings are 1 byte per character. This
* will produce some pretty odd looking output!
*/
enum ASN1_STRFLGS_IGNORE_TYPE = 0x20;
/* If this is set we include the string type in the output */
enum ASN1_STRFLGS_SHOW_TYPE = 0x40;
/* This determines which strings to display and which to
* 'dump' (hex dump of content octets or DER encoding). We can
* only dump non character strings or everything. If we
* don't dump 'unknown' they are interpreted as character
* strings with 1 octet per character and are subject to
* the usual escaping options.
*/
enum ASN1_STRFLGS_DUMP_ALL = 0x80;
enum ASN1_STRFLGS_DUMP_UNKNOWN = 0x100;
/* These determine what 'dumping' does, we can dump the
* content octets or the DER encoding: both use the
* RFC2253 #XXXXX notation.
*/
enum ASN1_STRFLGS_DUMP_DER = 0x200;
/* All the string flags consistent with RFC2253,
* escaping control characters isn't essential in
* RFC2253 but it is advisable anyway.
*/
enum ASN1_STRFLGS_RFC2253 = (ASN1_STRFLGS_ESC_2253 |
ASN1_STRFLGS_ESC_CTRL |
ASN1_STRFLGS_ESC_MSB |
ASN1_STRFLGS_UTF8_CONVERT |
ASN1_STRFLGS_DUMP_UNKNOWN |
ASN1_STRFLGS_DUMP_DER);
/+mixin DECLARE_STACK_OF!(ASN1_INTEGER);+/
mixin DECLARE_ASN1_SET_OF!(ASN1_INTEGER);
/+mixin DECLARE_STACK_OF!(ASN1_GENERALSTRING);+/
struct asn1_type_st
{
int type;
union value_ {
char* ptr;
ASN1_BOOLEAN boolean;
ASN1_STRING* asn1_string;
ASN1_OBJECT* object;
ASN1_INTEGER* integer;
ASN1_ENUMERATED* enumerated;
ASN1_BIT_STRING* bit_string;
ASN1_OCTET_STRING* octet_string;
ASN1_PRINTABLESTRING* printablestring;
ASN1_T61STRING* t61string;
ASN1_IA5STRING* ia5string;
ASN1_GENERALSTRING* generalstring;
ASN1_BMPSTRING* bmpstring;
ASN1_UNIVERSALSTRING* universalstring;
ASN1_UTCTIME* utctime;
ASN1_GENERALIZEDTIME* generalizedtime;
ASN1_VISIBLESTRING* visiblestring;
ASN1_UTF8STRING* utf8string;
/* set and sequence are left complete and still
* contain the set or sequence bytes */
ASN1_STRING* set;
ASN1_STRING* sequence;
ASN1_VALUE* asn1_value;
}
value_ value;
}
alias asn1_type_st ASN1_TYPE;
/+mixin DECLARE_STACK_OF!(ASN1_TYPE);+/
mixin DECLARE_ASN1_SET_OF!(ASN1_TYPE);
alias STACK_OF!(ASN1_TYPE) ASN1_SEQUENCE_ANY;
mixin(DECLARE_ASN1_ENCODE_FUNCTIONS_const!("ASN1_SEQUENCE_ANY", "ASN1_SEQUENCE_ANY"));
mixin(DECLARE_ASN1_ENCODE_FUNCTIONS_const!("ASN1_SEQUENCE_ANY", "ASN1_SET_ANY"));
struct NETSCAPE_X509_st {
ASN1_OCTET_STRING* header;
X509* cert;
}
alias NETSCAPE_X509_st NETSCAPE_X509;
/* This is used to contain a list of bit names */
struct BIT_STRING_BITNAME_st {
int bitnum;
const(char)* lname;
const(char)* sname;
}
alias BIT_STRING_BITNAME_st BIT_STRING_BITNAME;
auto M_ASN1_STRING_length()(ASN1_STRING* x) { return x.length; }
void M_ASN1_STRING_length_set()(ASN1_STRING* x, int n) { x.length = n; }
auto M_ASN1_STRING_type()(ASN1_STRING* x) { return x.type; }
auto M_ASN1_STRING_data()(ASN1_STRING* x) { return x.data; }
/* Macros for string operations */
ASN1_BIT_STRING* M_ASN1_BIT_STRING_new()() { return cast(ASN1_BIT_STRING*)ASN1_STRING_type_new(V_ASN1_BIT_STRING); }
void M_ASN1_BIT_STRING_free()(ASN1_BIT_STRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_BIT_STRING* M_ASN1_BIT_STRING_dup()(ASN1_BIT_STRING* a) { return cast(ASN1_BIT_STRING*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
auto M_ASN1_BIT_STRING_cmp()(const(ASN1_BIT_STRING)* a, const(ASN1_BIT_STRING)* b) { return ASN1_STRING_cmp(cast(const(ASN1_STRING)*)a, cast(const(ASN1_STRING)*)b); }
auto M_ASN1_BIT_STRING_set()(ASN1_BIT_STRING* a,const(void)* b, int c){ return ASN1_STRING_set(cast(ASN1_STRING*)a, b, c); }
ASN1_INTEGER* M_ASN1_INTEGER_new()() { return cast(ASN1_INTEGER*)ASN1_STRING_type_new(V_ASN1_INTEGER); }
void M_ASN1_INTEGER_free()(ASN1_INTEGER* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_INTEGER* M_ASN1_INTEGER_dup()(ASN1_INTEGER* a) { return cast(ASN1_INTEGER*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
auto M_ASN1_INTEGER_cmp()(const(ASN1_INTEGER)* a, const(ASN1_INTEGER)* b) { return ASN1_STRING_cmp(cast(const(ASN1_STRING)*)a, cast(const(ASN1_STRING)*)b); }
ASN1_ENUMERATED* M_ASN1_ENUMERATED_new()() { return cast(ASN1_ENUMERATED*)ASN1_STRING_type_new(V_ASN1_ENUMERATED); }
void M_ASN1_ENUMERATED_free()(ASN1_ENUMERATED* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_ENUMERATED* M_ASN1_ENUMERATED_dup()(ASN1_ENUMERATED* a) { return cast(ASN1_ENUMERATED*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
auto M_ASN1_ENUMERATED_cmp()(const(ASN1_ENUMERATED)* a, const(ASN1_ENUMERATED)* b) { return ASN1_STRING_cmp(cast(const(ASN1_STRING)*)a, cast(const(ASN1_STRING)*)b); }
ASN1_OCTET_STRING* M_ASN1_OCTET_STRING_new()() { return cast(ASN1_OCTET_STRING*)ASN1_STRING_type_new(V_ASN1_OCTET_STRING); }
void M_ASN1_OCTET_STRING_free()(ASN1_OCTET_STRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_OCTET_STRING* M_ASN1_OCTET_STRING_dup()(ASN1_OCTET_STRING* a) { return cast(ASN1_OCTET_STRING*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
auto M_ASN1_OCTET_STRING_cmp()(const(ASN1_OCTET_STRING)* a, const(ASN1_OCTET_STRING)* b) { return ASN1_STRING_cmp(cast(const(ASN1_STRING)*)a, cast(const(ASN1_STRING)*)b); }
auto M_ASN1_OCTET_STRING_set()(ASN1_OCTET_STRING* a,const(void)* b, int c){ return ASN1_STRING_set(cast(ASN1_STRING*)a, b, c); }
auto M_ASN1_OCTET_STRING_print()(BIO* a,const(ASN1_OCTET_STRING)* b) { return ASN1_STRING_print(a,cast(ASN1_STRING*)b); }
auto M_i2d_ASN1_OCTET_STRING()(const(ASN1_OCTET_STRING)* a, ubyte** pp) { return i2d_ASN1_bytes(cast(ASN1_STRING*)a,pp,V_ASN1_OCTET_STRING,V_ASN1_UNIVERSAL); }
enum B_ASN1_TIME =
B_ASN1_UTCTIME |
B_ASN1_GENERALIZEDTIME;
enum B_ASN1_PRINTABLE =
B_ASN1_NUMERICSTRING|
B_ASN1_PRINTABLESTRING|
B_ASN1_T61STRING|
B_ASN1_IA5STRING|
B_ASN1_BIT_STRING|
B_ASN1_UNIVERSALSTRING|
B_ASN1_BMPSTRING|
B_ASN1_UTF8STRING|
B_ASN1_SEQUENCE|
B_ASN1_UNKNOWN;
enum B_ASN1_DIRECTORYSTRING =
B_ASN1_PRINTABLESTRING|
B_ASN1_TELETEXSTRING|
B_ASN1_BMPSTRING|
B_ASN1_UNIVERSALSTRING|
B_ASN1_UTF8STRING;
enum B_ASN1_DISPLAYTEXT =
B_ASN1_IA5STRING|
B_ASN1_VISIBLESTRING|
B_ASN1_BMPSTRING|
B_ASN1_UTF8STRING;
/+
auto M_ASN1_PRINTABLE_new()() { return ASN1_STRING_type_new(V_ASN1_T61STRING); }
void M_ASN1_PRINTABLE_free()(ASN1_PRINTABLE* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_PRINTABLE(a,pp) i2d_ASN1_bytes((ASN1_STRING*)a,\
pp,a->type,V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_PRINTABLE(a,pp,l) \
d2i_ASN1_type_bytes((ASN1_STRING**)a,pp,l, \
B_ASN1_PRINTABLE)
auto M_DIRECTORYSTRING_new()() { return ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING); }
void M_DIRECTORYSTRING_free()(DIRECTORYSTRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_DIRECTORYSTRING(a,pp) i2d_ASN1_bytes((ASN1_STRING*)a,\
pp,a->type,V_ASN1_UNIVERSAL)
#define M_d2i_DIRECTORYSTRING(a,pp,l) \
d2i_ASN1_type_bytes((ASN1_STRING**)a,pp,l, \
B_ASN1_DIRECTORYSTRING)
auto M_DISPLAYTEXT_new()() { return ASN1_STRING_type_new(V_ASN1_VISIBLESTRING); }
void M_DISPLAYTEXT_free()(DISPLAYTEXT* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_DISPLAYTEXT(a,pp) i2d_ASN1_bytes((ASN1_STRING*)a,\
pp,a->type,V_ASN1_UNIVERSAL)
#define M_d2i_DISPLAYTEXT(a,pp,l) \
d2i_ASN1_type_bytes((ASN1_STRING**)a,pp,l, \
B_ASN1_DISPLAYTEXT)
ASN1_PRINTABLESTRING* M_ASN1_PRINTABLESTRING_new()() { return cast(ASN1_PRINTABLESTRING*)ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING); }
void M_ASN1_PRINTABLESTRING_free()(ASN1_PRINTABLESTRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_PRINTABLESTRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_PRINTABLESTRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_PRINTABLESTRING(a,pp,l) \
(ASN1_PRINTABLESTRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_PRINTABLESTRING)
ASN1_T61STRING* M_ASN1_T61STRING_new()() { return cast(ASN1_T61STRING*)ASN1_STRING_type_new(V_ASN1_T61STRING); }
void M_ASN1_T61STRING_free()(ASN1_T61STRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_T61STRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_T61STRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_T61STRING(a,pp,l) \
(ASN1_T61STRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_T61STRING)
ASN1_IA5STRING* M_ASN1_IA5STRING_new()() { return cast(ASN1_IA5STRING*)ASN1_STRING_type_new(V_ASN1_IA5STRING); }
void M_ASN1_IA5STRING_free()(ASN1_IA5STRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_ASN1_IA5STRING_dup(a) \
(ASN1_IA5STRING*)ASN1_STRING_dup((const(ASN1_STRING)*)a)
#define M_i2d_ASN1_IA5STRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_IA5STRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_IA5STRING(a,pp,l) \
(ASN1_IA5STRING*)d2i_ASN1_type_bytes((ASN1_STRING**)a,pp,l,\
B_ASN1_IA5STRING)
ASN1_UTCTIME* M_ASN1_UTCTIME_new()() { return cast(ASN1_UTCTIME*)ASN1_STRING_type_new(V_ASN1_UTCTIME); }
void M_ASN1_UTCTIME_free()(ASN1_UTCTIME* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_UTCTIME* M_ASN1_UTCTIME_dup()(ASN1_UTCTIME* a) { return cast(ASN1_UTCTIME*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
ASN1_GENERALIZEDTIME* M_ASN1_GENERALIZEDTIME_new()() { return cast(ASN1_GENERALIZEDTIME*)ASN1_STRING_type_new(V_ASN1_GENERALIZEDTIME); }
void M_ASN1_GENERALIZEDTIME_free()(ASN1_GENERALIZEDTIME* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_GENERALIZEDTIME* M_ASN1_GENERALIZEDTIME_dup()(ASN1_GENERALIZEDTIME* a) { return cast(ASN1_GENERALIZEDTIME*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
ASN1_TIME* M_ASN1_TIME_new()() { return cast(ASN1_TIME*)ASN1_STRING_type_new(V_ASN1_UTCTIME); }
void M_ASN1_TIME_free()(ASN1_TIME* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
ASN1_TIME* M_ASN1_TIME_dup()(ASN1_TIME* a) { return cast(ASN1_TIME*)ASN1_STRING_dup(cast(ASN1_STRING*)a); }
ASN1_GENERALSTRING* M_ASN1_GENERALSTRING_new()() { return cast(ASN1_GENERALSTRING*)ASN1_STRING_type_new(V_ASN1_GENERALSTRING); }
void M_ASN1_GENERALSTRING_free()(ASN1_GENERALSTRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_GENERALSTRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_GENERALSTRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_GENERALSTRING(a,pp,l) \
(ASN1_GENERALSTRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_GENERALSTRING)
ASN1_UNIVERSALSTRING* M_ASN1_UNIVERSALSTRING_new()() { return cast(ASN1_UNIVERSALSTRING*)ASN1_STRING_type_new(V_ASN1_UNIVERSALSTRING); }
void M_ASN1_UNIVERSALSTRING_free()(ASN1_UNIVERSALSTRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_UNIVERSALSTRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_UNIVERSALSTRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_UNIVERSALSTRING(a,pp,l) \
(ASN1_UNIVERSALSTRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_UNIVERSALSTRING)
ASN1_BMPSTRING* M_ASN1_BMPSTRING_new()() { return cast(ASN1_BMPSTRING*)ASN1_STRING_type_new(V_ASN1_BMPSTRING); }
void M_ASN1_BMPSTRING_free()(ASN1_BMPSTRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_BMPSTRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_BMPSTRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_BMPSTRING(a,pp,l) \
(ASN1_BMPSTRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_BMPSTRING)
ASN1_VISIBLESTRING* M_ASN1_VISIBLESTRING_new()() { return cast(ASN1_VISIBLESTRING*)ASN1_STRING_type_new(V_ASN1_VISIBLESTRING); }
void M_ASN1_VISIBLESTRING_free()(ASN1_VISIBLESTRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_VISIBLESTRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_VISIBLESTRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_VISIBLESTRING(a,pp,l) \
(ASN1_VISIBLESTRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_VISIBLESTRING)
ASN1_UTF8STRING* M_ASN1_UTF8STRING_new()() { return cast(ASN1_UTF8STRING*)ASN1_STRING_type_new(V_ASN1_UTF8STRING); }
void M_ASN1_UTF8STRING_free()(ASN1_UTF8STRING* a) { ASN1_STRING_free(cast(ASN1_STRING*)a); }
#define M_i2d_ASN1_UTF8STRING(a,pp) \
i2d_ASN1_bytes((ASN1_STRING*)a,pp,V_ASN1_UTF8STRING,\
V_ASN1_UNIVERSAL)
#define M_d2i_ASN1_UTF8STRING(a,pp,l) \
(ASN1_UTF8STRING*)d2i_ASN1_type_bytes\
((ASN1_STRING**)a,pp,l,B_ASN1_UTF8STRING)
+/
/* for the is_set parameter to i2d_ASN1_SET */
enum IS_SEQUENCE = 0;
enum IS_SET = 1;
mixin(DECLARE_ASN1_FUNCTIONS_fname!("ASN1_TYPE", "ASN1_ANY", "ASN1_TYPE"));
int ASN1_TYPE_get(ASN1_TYPE* a);
void ASN1_TYPE_set(ASN1_TYPE* a, int type, void* value);
int ASN1_TYPE_set1(ASN1_TYPE* a, int type, const(void)* value);
int ASN1_TYPE_cmp(ASN1_TYPE* a, ASN1_TYPE* b);
ASN1_OBJECT* ASN1_OBJECT_new();
void ASN1_OBJECT_free(ASN1_OBJECT* a);
int i2d_ASN1_OBJECT(ASN1_OBJECT* a,ubyte** pp);
ASN1_OBJECT* c2i_ASN1_OBJECT(ASN1_OBJECT** a,const(ubyte)** pp,
c_long length);
ASN1_OBJECT* d2i_ASN1_OBJECT(ASN1_OBJECT** a,const(ubyte)** pp,
c_long length);
mixin(DECLARE_ASN1_ITEM!"ASN1_OBJECT");
/+mixin DECLARE_STACK_OF!(ASN1_OBJECT);+/
mixin DECLARE_ASN1_SET_OF!(ASN1_OBJECT);
ASN1_STRING* ASN1_STRING_new();
void ASN1_STRING_free(ASN1_STRING* a);
int ASN1_STRING_copy(ASN1_STRING* dst, const(ASN1_STRING)* str);
ASN1_STRING* ASN1_STRING_dup(const(ASN1_STRING)* a);
ASN1_STRING* ASN1_STRING_type_new(int type );
int ASN1_STRING_cmp(const(ASN1_STRING)* a, const(ASN1_STRING)* b);
/* Since this is used to store all sorts of things, via macros, for now, make
its data void* */
int ASN1_STRING_set(ASN1_STRING* str, const(void)* data, int len);
void ASN1_STRING_set0(ASN1_STRING* str, void* data, int len);
int ASN1_STRING_length(const(ASN1_STRING)* x);
void ASN1_STRING_length_set(ASN1_STRING* x, int n);
int ASN1_STRING_type(ASN1_STRING* x);
ubyte* ASN1_STRING_data(ASN1_STRING* x);
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_BIT_STRING");
int i2c_ASN1_BIT_STRING(ASN1_BIT_STRING* a,ubyte** pp);
ASN1_BIT_STRING* c2i_ASN1_BIT_STRING(ASN1_BIT_STRING** a,const(ubyte)** pp,
c_long length);
int ASN1_BIT_STRING_set(ASN1_BIT_STRING* a, ubyte* d,
int length );
int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING* a, int n, int value);
int ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING* a, int n);
int ASN1_BIT_STRING_check(ASN1_BIT_STRING* a,
ubyte* flags, int flags_len);
version(OPENSSL_NO_BIO) {} else {
int ASN1_BIT_STRING_name_print(BIO* out_, ASN1_BIT_STRING* bs,
BIT_STRING_BITNAME* tbl, int indent);
}
int ASN1_BIT_STRING_num_asc(char* name, BIT_STRING_BITNAME* tbl);
int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING* bs, char* name, int value,
BIT_STRING_BITNAME* tbl);
int i2d_ASN1_BOOLEAN(int a,ubyte** pp);
int d2i_ASN1_BOOLEAN(int* a,const(ubyte)** pp,c_long length);
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_INTEGER");
int i2c_ASN1_INTEGER(ASN1_INTEGER* a,ubyte** pp);
ASN1_INTEGER* c2i_ASN1_INTEGER(ASN1_INTEGER** a,const(ubyte)** pp,
c_long length);
ASN1_INTEGER* d2i_ASN1_UINTEGER(ASN1_INTEGER** a,const(ubyte)** pp,
c_long length);
ASN1_INTEGER* ASN1_INTEGER_dup(const(ASN1_INTEGER)* x);
int ASN1_INTEGER_cmp(const(ASN1_INTEGER)* x, const(ASN1_INTEGER)* y);
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_ENUMERATED");
int ASN1_UTCTIME_check(ASN1_UTCTIME* a);
ASN1_UTCTIME* ASN1_UTCTIME_set(ASN1_UTCTIME* s,time_t t);
ASN1_UTCTIME* ASN1_UTCTIME_adj(ASN1_UTCTIME* s, time_t t,
int offset_day, c_long offset_sec);
int ASN1_UTCTIME_set_string(ASN1_UTCTIME* s, const(char)* str);
int ASN1_UTCTIME_cmp_time_t(const(ASN1_UTCTIME)* s, time_t t);
version (none) {
time_t ASN1_UTCTIME_get(const(ASN1_UTCTIME)* s);
}
int ASN1_GENERALIZEDTIME_check(ASN1_GENERALIZEDTIME* a);
ASN1_GENERALIZEDTIME* ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME* s,time_t t);
ASN1_GENERALIZEDTIME* ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME* s,
time_t t, int offset_day, c_long offset_sec);
int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME* s, const(char)* str);
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_OCTET_STRING");
ASN1_OCTET_STRING* ASN1_OCTET_STRING_dup(const(ASN1_OCTET_STRING)* a);
int ASN1_OCTET_STRING_cmp(const(ASN1_OCTET_STRING)* a, const(ASN1_OCTET_STRING)* b);
int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING* str, const(ubyte)* data, int len);
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_VISIBLESTRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_UNIVERSALSTRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_UTF8STRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_NULL");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_BMPSTRING");
int UTF8_getc(const(char)* str, int len, c_ulong* val);
int UTF8_putc(char* str, int len, c_ulong value);
mixin(DECLARE_ASN1_FUNCTIONS_name!("ASN1_STRING", "ASN1_PRINTABLE"));
mixin(DECLARE_ASN1_FUNCTIONS_name!("ASN1_STRING", "DIRECTORYSTRING"));
mixin(DECLARE_ASN1_FUNCTIONS_name!("ASN1_STRING", "DISPLAYTEXT"));
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_PRINTABLESTRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_T61STRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_IA5STRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_GENERALSTRING");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_UTCTIME");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_GENERALIZEDTIME");
mixin(DECLARE_ASN1_FUNCTIONS!"ASN1_TIME");
mixin(DECLARE_ASN1_ITEM!"ASN1_OCTET_STRING_NDEF");
ASN1_TIME* ASN1_TIME_set(ASN1_TIME* s,time_t t);
ASN1_TIME* ASN1_TIME_adj(ASN1_TIME* s,time_t t,
int offset_day, c_long offset_sec);
int ASN1_TIME_check(ASN1_TIME* t);
ASN1_GENERALIZEDTIME* ASN1_TIME_to_generalizedtime(ASN1_TIME* t, ASN1_GENERALIZEDTIME** out_);
int ASN1_TIME_set_string(ASN1_TIME* s, const(char)* str);
int i2d_ASN1_SET(STACK_OF!(OPENSSL_BLOCK) *a, ubyte** pp,
i2d_of_void* i2d, int ex_tag, int ex_class,
int is_set);
STACK_OF!(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF!(OPENSSL_BLOCK) **a,
const(ubyte)** pp,
c_long length, d2i_of_void* d2i,
ExternC!(void function(OPENSSL_BLOCK)) free_func, int ex_tag,
int ex_class);
version(OPENSSL_NO_BIO) {} else {
int i2a_ASN1_INTEGER(BIO* bp, ASN1_INTEGER* a);
int a2i_ASN1_INTEGER(BIO* bp,ASN1_INTEGER* bs,char* buf,int size);
int i2a_ASN1_ENUMERATED(BIO* bp, ASN1_ENUMERATED* a);
int a2i_ASN1_ENUMERATED(BIO* bp,ASN1_ENUMERATED* bs,char* buf,int size);
int i2a_ASN1_OBJECT(BIO* bp,ASN1_OBJECT* a);
int a2i_ASN1_STRING(BIO* bp,ASN1_STRING* bs,char* buf,int size);
int i2a_ASN1_STRING(BIO* bp, ASN1_STRING* a, int type);
}
int i2t_ASN1_OBJECT(char* buf,int buf_len,ASN1_OBJECT* a);
int a2d_ASN1_OBJECT(ubyte* out_,int olen, const(char)* buf, int num);
ASN1_OBJECT* ASN1_OBJECT_create(int nid, ubyte* data,int len,
const(char)* sn, const(char)* ln);
int ASN1_INTEGER_set(ASN1_INTEGER* a, c_long v);
c_long ASN1_INTEGER_get(const(ASN1_INTEGER)* a);
ASN1_INTEGER* BN_to_ASN1_INTEGER(const(BIGNUM)* bn, ASN1_INTEGER* ai);
BIGNUM* ASN1_INTEGER_to_BN(const(ASN1_INTEGER)* ai,BIGNUM* bn);
int ASN1_ENUMERATED_set(ASN1_ENUMERATED* a, c_long v);
c_long ASN1_ENUMERATED_get(ASN1_ENUMERATED* a);
ASN1_ENUMERATED* BN_to_ASN1_ENUMERATED(BIGNUM* bn, ASN1_ENUMERATED* ai);
BIGNUM* ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED* ai,BIGNUM* bn);
/* General */
/* given a string, return the correct type, max is the maximum length */
int ASN1_PRINTABLE_type(const(ubyte)* s, int max);
int i2d_ASN1_bytes(ASN1_STRING* a, ubyte** pp, int tag, int xclass);
ASN1_STRING* d2i_ASN1_bytes(ASN1_STRING** a, const(ubyte)** pp,
c_long length, int Ptag, int Pclass);
c_ulong ASN1_tag2bit(int tag);
/* type is one or more of the B_ASN1_ values. */
ASN1_STRING* d2i_ASN1_type_bytes(ASN1_STRING** a,const(ubyte)** pp,
c_long length,int type);
/* PARSING */
int asn1_Finish(ASN1_CTX* c);
int asn1_const_Finish(ASN1_const_CTX* c);
/* SPECIALS */
int ASN1_get_object(const(ubyte)** pp, c_long* plength, int* ptag,
int* pclass, c_long omax);
int ASN1_check_infinite_end(ubyte** p,c_long len);
int ASN1_const_check_infinite_end(const(ubyte)** p,c_long len);
void ASN1_put_object(ubyte** pp, int constructed, int length,
int tag, int xclass);
int ASN1_put_eoc(ubyte** pp);
int ASN1_object_size(int constructed, int length, int tag);
/* Used to implement other functions */
void* ASN1_dup(i2d_of_void* i2d, d2i_of_void* d2i, void* x);
auto ASN1_dup_of(type)(I2D_OF!type* i2d, D2I_OF!type* d2i, type* x) {
return cast(type*)(ASN1_dup(CHECKED_I2D_OF!type(i2d),
CHECKED_D2I_OF!type(d2i),
CHECKED_PTR_OF!type(x)));
}
auto ASN1_dup_of_const(type)(I2D_OF!(const(type))* i2d, D2I_OF!type* d2i, const(type)* x) {
return cast(type*)(ASN1_dup(CHECKED_I2D_OF!(const(type))(i2d),
CHECKED_D2I_OF!type(d2i),
CHECKED_PTR_OF!(const(type))(x)));
}