Rev

Rev 2230 | Rev 2655 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | Bug Tracker

Rev 2230 Rev 2398
Line 6... Line 6...
6
##  Copyleft (c) 2015
6
##  Copyleft (c) 2015
7
##  This code is provided under the CeCill-C license agreement.
7
##  This code is provided under the CeCill-C license agreement.
8
######################################################################
8
######################################################################
9
*********************************************************************/
9
*********************************************************************/
10
#define _CRT_SECURE_NO_WARNINGS
10
#define _CRT_SECURE_NO_WARNINGS
-
 
11
#define _USE_MATH_DEFINES
-
 
12
11
#include <stdio.h>
13
#include <stdio.h>
12
#include "cxml/cxml.h"
14
#include "../cxml/cxml.h"
13
#include "cshared/copts.h"
15
#include "../cshared/copts.h"
14
#include "cshared/cserialize.h"
16
#include "../cshared/cserialize.h"
15
#include "cshared/cstr.h"
17
#include "../cshared/cstr.h"
16
18
17
#include "ecc_api.h"
19
#include "ecc_api.h"
18
#include "mkgmtime.h"
20
#include "mkgmtime.h"
19
#include <string.h>
21
#include <string.h>
20
#include <stdlib.h>
22
#include <stdlib.h>
21
#include <ctype.h>
23
#include <ctype.h>
22
#include <assert.h>
24
#include <assert.h>
23
#include <limits.h>
25
#include <limits.h>
24
#include <time.h>
26
#include <time.h>
25
#include <math.h>
27
#include <math.h>
-
 
28
-
 
29
#if defined(__CYGWIN__)
-
 
30
#define floorl(X) __builtin_floor(X)
-
 
31
#endif
26
32
27
//#define DEBUG_BOOKMARKS
33
//#define DEBUG_BOOKMARKS
28
//#define DEBUG_DATA
34
//#define DEBUG_DATA
29
#define MAX_BOOKMARKS 16
35
#define MAX_BOOKMARKS 16
30
36
31
typedef struct bookmark_t bookmark_t;
37
typedef struct bookmark_t bookmark_t;
32
struct bookmark_t {
38
struct bookmark_t {
33
        bookmark_t * prev;
39
        bookmark_t * prev;
34
        char       * ptr;
40
        char       * ptr;
35
};
41
};
-
 
42
-
 
43
typedef enum {
-
 
44
        si_self,
-
 
45
        si_digest,
-
 
46
        si_certificate,
-
 
47
        si_certificate_chain,
-
 
48
        si_digest_with_other_algorithm,
-
 
49
        si_other
-
 
50
} SignerInfoType;
36
51
37
typedef struct cert_cxml_handler_t
52
typedef struct cert_cxml_handler_t
38
{
53
{
39
        cxml_handler_t  h;
54
        cxml_handler_t  h;
40
        unsigned int    subject_type;
55
        unsigned int    subject_type;
41
        int             signer_type;
56
        int             signer_type;
42
        const char    * signer;
57
        const char    * signer;
-
 
58
        const char    * signer_digest;
43
        int             vr_type;
59
        int             vr_type;
44
        int             sa_type;
60
        int             sa_type;
45
        void          * verificationKey;
61
        void          * verificationKey;
46
        void          * encryptionKey;
62
        void          * encryptionKey;
47
63
Line 145... Line 161...
145
static int region_none_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
161
static int region_none_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
146
static int region_circle_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
162
static int region_circle_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
147
static int region_rectangle_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
163
static int region_rectangle_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
148
static int region_polygon_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
164
static int region_polygon_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
149
static int region_id_tag (cxml_handler_t* const h, cxml_tag_t * const tag);
165
static int region_id_tag(cxml_handler_t* const h, cxml_tag_t * const tag);
-
 
166
static int region_region_tag(cxml_handler_t* const h, cxml_tag_t * const tag);
-
 
167
static int region_region_text(cxml_handler_t* const h, char * const text, int length);
150
static const cxml_taghandler_t h_restriction[] = {
168
static const cxml_taghandler_t h_restriction[] = {
-
 
169
    {"region",     region_region_tag,    region_region_text, NULL },
151
    {"none",       region_none_tag,         NULL, NULL },
170
    {"none",       region_none_tag,      NULL,               NULL },
152
    {"circle",     region_circle_tag,         NULL, NULL },
171
    {"circle",     region_circle_tag,    NULL,               NULL },
153
    {"rectangle",  region_rectangle_tag,      NULL, h_location_list },
172
    {"rectangle",  region_rectangle_tag, NULL,               h_location_list },
154
    {"polygon",    region_polygon_tag,        NULL, h_location_list },
173
    {"polygon",    region_polygon_tag,   NULL,               h_location_list },
155
    {"id",         region_id_tag,             NULL, NULL },
174
    {"id",         region_id_tag,        NULL,               NULL },
Line 198... Line 217...
198
217
199
#define STR2ENUM(N,V) _str_2_enum(N, sizeof(N)/sizeof(N[0]), V)
218
#define STR2ENUM(N,V) _str_2_enum(N, sizeof(N)/sizeof(N[0]), V)
200
219
201
static int _str_2_enum(const char ** values, size_t size, const char * v)
220
static int _str_2_enum(const char ** values, size_t size, const char * v)
202
{
221
{
203
        while (*v && isspace(*v))v++;
222
        while (*v && cisspace(*v))v++;
204
        if (*v){
223
        if (*v){
205
                size_t i;
224
                size_t i;
206
                for (i = 0; i<size; i++){
225
                for (i = 0; i<size; i++){
207
                        if (values[i] && 0 == strcmp(values[i], v)) {
226
                        if (values[i] && 0 == strcmp(values[i], v)) {
208
                                return i;
227
                                return i;
209
                        }
228
                        }
210
                }
229
                }
211
                if (isdigit(*v)){
230
                if (cisdigit(*v)){
212
                        return strtoul(v, NULL, 0);
231
                        return strtoul(v, NULL, 0);
213
                }
232
                }
214
        }
233
        }
215
        return -1;
234
        return -1;
216
}
235
}
Line 241... Line 260...
241
static int          _reuseKeys = 0;
260
static int          _reuseKeys = 0;
242
261
243
static long         _refLat = 0;
262
static long         _refLat = 0;
244
static long         _refLon = 0;
263
static long         _refLon = 0;
245
264
-
 
265
static const long double _latTMDPerMetter = 180.0 / M_PI / 0.6378;
-
 
266
static long double       _lonTMDPerMetter = 180.0 / M_PI / 0.6378;
246
static const char * _cfgFile = NULL;
267
static const char * _cfgFile = NULL;
247
268
-
 
269
static void _setup_default_time()
-
 
270
{
-
 
271
        time_t t;
-
 
272
        struct tm * ptm;
-
 
273
        struct tm   tm = {0};
-
 
274
        memset(&tm, 0, sizeof(tm));
-
 
275
        time(&t);
-
 
276
        ptm = gmtime(&t);
-
 
277
        tm.tm_mday = 1;
-
 
278
        tm.tm_year = ptm->tm_year;
-
 
279
        _defaultTime = mkitstime32(&tm);
-
 
280
}
248
281
249
static int _time_option(const copt_t * opt, const char * option, const copt_value_t * value)
282
static int _time_option(const copt_t * opt, const char * option, const copt_value_t * value)
250
{
283
{
251
        _defaultTime = _convert_time(value->v_str);
284
        _defaultTime = _convert_time(value->v_str);
252
        return (_defaultTime == (unsigned int)-1) ? -1 : 0;
285
        return (_defaultTime == (unsigned int)-1) ? -1 : 0;
Line 255... Line 288...
255
static int _refPoint_option(const copt_t * opt, const char * option, const copt_value_t * value)
288
static int _refPoint_option(const copt_t * opt, const char * option, const copt_value_t * value)
256
{
289
{
257
        char * e;
290
        char * e;
258
        long double lat, lon;
291
        long double lat, lon;
259
        lat = strtold(value->v_str, &e);
292
        lat = strtold(value->v_str, &e);
260
        if (*e == ':'){
293
        if (*e == ':' || *e == ','){
261
                lon = strtold(e + 1, &e);
294
                lon = strtold(e + 1, &e);
262
                if (*e == 0){
295
                if (*e == 0){
263
                        if (lat <= 90.0 &&  lat >= -90.0) lat *= 10000000.0; // degree
296
                        if (lat <= 90.0 &&  lat >= -90.0) lat *= 10000000.0; // degree
264
                        _refLat = (int32_t)floorl(lat);
297
                        _refLat = (int32_t)floorl(lat);
265
                        if (lon <= 180.0 &&  lon >= -180.0) lon *= 10000000.0; // degree
298
                        if (lon <= 180.0 &&  lon >= -180.0) lon *= 10000000.0; // degree
266
                        _refLon = (int32_t)floorl(lon);
299
                        _refLon = (int32_t)floorl(lon);
-
 
300
                        _lonTMDPerMetter = 180.0 / M_PI / 0.6378 / cos((lat/10000000.0) * M_PI / 180.0);
267
                        return 0;
301
                        return 0;
268
                }
302
                }
269
        }
303
        }
270
        return -1;
304
        return -1;
271
}
305
}
Line 298... Line 332...
298
        int rc;
332
        int rc;
299
333
300
        cert_cxml_handler_t * h = cxml_st_handler_new(&Class, h_root);
334
        cert_cxml_handler_t * h = cxml_st_handler_new(&Class, h_root);
301
        h->vr_type = -1;
335
        h->vr_type = -1;
302
        h->sa_type = -1;
336
        h->sa_type = -1;
-
 
337
       
-
 
338
        // set default time to the begining of this year
-
 
339
        _setup_default_time();
303
       
340
       
304
        argc = coptions(argc, argv, COPT_HELP_NOVALUES , options);
341
        argc = coptions(argc, argv, COPT_HELP_NOVALUES , options);
305
342
306
    if(argc < 2){
343
    if(argc < 2){
307
                if(argc<0 && (0-argc)<((sizeof(options)/sizeof(options[0]))-1)){
344
                if(argc<0 && (0-argc)<((sizeof(options)/sizeof(options[0]))-1)){
Line 366... Line 403...
366
        if (cxml_tag_is_open(tag)){
403
        if (cxml_tag_is_open(tag)){
367
                if(_certName == NULL){
404
                if(_certName == NULL){
368
                        _certName = cxml_tag_attr_value(tag, "name");
405
                        _certName = cxml_tag_attr_value(tag, "name");
369
                        if(_certName == NULL){
406
                        if(_certName == NULL){
370
                                _certName = _profileName;
407
                                _certName = _profileName;
-
 
408
                        }
-
 
409
                        else if (!cstrequal(_certName, _profileName)){
-
 
410
                                fprintf(stderr, "WARNING: %s.xml: profile name differs from certificate name '%s'\n", _profileName, _certName);
371
                        }
411
                        }
372
                }
412
                }
373
                h->ptr = h->buf = malloc(4096);
413
                h->ptr = h->buf = malloc(4096);
374
                h->end = h->buf + 4096;
414
                h->end = h->buf + 4096;
375
                if (cxml_tag_attr_boolean(tag, "keep-existing")){
415
                if (cxml_tag_attr_boolean(tag, "keep-existing")){
Line 383... Line 423...
383
                                return CXML_RETURN_STOP;
423
                                return CXML_RETURN_STOP;
384
                        }
424
                        }
385
                }
425
                }
386
        }else{
426
        }else{
387
                FILE * f;
427
                FILE * f;
-
 
428
                char * path;
388
                char * path = h->ptr;
429
                path = h->ptr;
389
                char * end = cvstrncpy(path, h->end-path, _outPath, "/", _certName, ".crt", NULL);
430
                cvstrncpy(path, h->end-path, _outPath, "/", _certName, ".crt", NULL);
390
                f = fopen(path, "wb");
431
                f = fopen(path, "wb");
391
                if (!f){
432
                if (!f){
392
                        fprintf(stderr, "ERROR: Certificate write failed to '%s'\n", path);
433
                        fprintf(stderr, "ERROR: Certificate write failed to '%s'\n", path);
393
                }else{
434
                }else{
394
                        if (_outFormat == 0){
435
                        if (_outFormat == 0){
Line 429... Line 470...
429
        if (cxml_tag_is_open(tag)){
470
        if (cxml_tag_is_open(tag)){
430
                h->nTmpValue = 2;
471
                h->nTmpValue = 2;
431
                const char * v = cxml_tag_attr_value(tag, "version");
472
                const char * v = cxml_tag_attr_value(tag, "version");
432
                if(v == NULL)v = cxml_tag_attr_value(tag, "value");
473
                if(v == NULL)v = cxml_tag_attr_value(tag, "value");
433
                if(v){
474
                if(v){
434
                        while(isspace(*v))v++;
475
                        while(cisspace(*v))v++;
435
                        h->nTmpValue = strtoul(v, NULL, 0);
476
                        h->nTmpValue = strtoul(v, NULL, 0);
436
                }
477
                }
437
        }else{
478
        }else{
438
                cint8_write(h->nTmpValue, &h->ptr, h->end, &rc);
479
                cint8_write(h->nTmpValue, &h->ptr, h->end, &rc);
439
        }
480
        }
Line 443... Line 484...
443
static int certificate_version_text(cxml_handler_t* const _h, char * const text, int length)
484
static int certificate_version_text(cxml_handler_t* const _h, char * const text, int length)
444
{
485
{
445
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
486
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
446
        if(text){
487
        if(text){
447
                const char * p = text;
488
                const char * p = text;
448
                while(*p && isspace(*p))p++;
489
                while(*p && cisspace(*p))p++;
449
                if(*p) h->nTmpValue = strtoul(p, NULL, 0);
490
                if(*p) h->nTmpValue = strtoul(p, NULL, 0);
450
        }
491
        }
451
        return 0;
492
        return 0;
452
}
493
}
453
494
454
static const char * _signer_types [] = {
495
static const char * _signer_types [] = {
455
        "self",
496
        "self",
456
        "digest",
497
        "digest",
457
        "certificate",
498
        "certificate",
-
 
499
        "certificate_chain",
458
        "chain",
500
        "other_digest",
459
        "other",
501
        "other",
460
};
502
};
461
503
462
static size_t load_certificate(const char * path, char * ptr, const char * e)
504
static size_t load_certificate(const char * path, char * ptr, const char * e)
463
{
505
{
Line 475... Line 517...
475
        fseek(f, 0, SEEK_SET);
517
        fseek(f, 0, SEEK_SET);
476
        if (size < 67){
518
        if (size < 67){
477
                fprintf(stderr, "%s: File too small\n", path);
519
                fprintf(stderr, "%s: File too small\n", path);
478
                return -1;
520
                return -1;
479
        }
521
        }
480
        if (size > (e - cert)){
522
        if (size > (size_t)(e - cert)){
481
                fprintf(stderr, "%s: no enough space\n", path);
523
                fprintf(stderr, "%s: no enough space\n", path);
482
                return -1;
524
                return -1;
483
        }
525
        }
484
        if (size != fread(cert, 1, size, f)){
526
        if (size != fread(cert, 1, size, f)){
485
                perror(path);
527
                perror(path);
Line 492... Line 534...
492
                        size = c - cert;
534
                        size = c - cert;
493
                }
535
                }
494
        }
536
        }
495
        return size;
537
        return size;
496
}
538
}
-
 
539
-
 
540
static const char * _pk_algorithms[] = {
-
 
541
        [0] = "ecdsa_nistp256_with_sha256",
-
 
542
        [1] = "ecies_nistp256",
-
 
543
};
-
 
544
-
 
545
static const char * _sym_algorithms[] = {
-
 
546
        [0] = "aes_128_ccm",
-
 
547
};
-
 
548
static const char * _point_types[] = {
-
 
549
        [0] = "x_coordinate_only",
-
 
550
        [1] = "compressed",
-
 
551
        [2] = "compressed_y0",
-
 
552
        [3] = "compressed_y1",
-
 
553
        [4] = "uncompressed"
-
 
554
};
497
555
498
static int certificate_signer_tag (cxml_handler_t* const _h, cxml_tag_t * const tag)
556
static int certificate_signer_tag (cxml_handler_t* const _h, cxml_tag_t * const tag)
499
{
557
{
500
        int rc = 0;
558
        int rc = 0;
-
 
559
        const char * v;
501
        // write signer info
560
        // write signer info
502
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
561
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
503
        if (cxml_tag_is_open(tag)){
562
        if (cxml_tag_is_open(tag)){
504
                h->signer_type = 1; // digest by default
563
                h->signer_type = si_digest; // digest by default
505
                const char * v = cxml_tag_attr_value(tag, "type");
564
                v = cxml_tag_attr_value(tag, "type");
506
                if(v){
565
                if(v){
507
                        h->signer_type = STR2ENUM(_signer_types, v);
566
                        h->signer_type = STR2ENUM(_signer_types, v);
508
                        if(h->signer_type <0){
567
                        if (h->signer_type <0){
509
                                fprintf(stderr, "%s: Unknown signer type\n", v);
568
                                fprintf(stderr, "%s: Unknown signer type\n", v);
510
                                return -1;
569
                                return -1;
511
                        }
570
                        }
512
                }
571
                }
513
                cint8_write(h->signer_type, &h->ptr, h->end, &rc);
572
                cint8_write(h->signer_type, &h->ptr, h->end, &rc);
514
573
515
                if (h->signer_type > 0){
574
                if (h->signer_type > si_self){
516
                        if (_signerName){
575
                        if (_signerName){
517
                                h->signer = _signerName;
576
                                h->signer = _signerName;
518
                        }
577
                        }
519
                        else{
578
                        else{
-
 
579
                                if (h->signer_type == si_digest || h->signer_type == si_digest_with_other_algorithm){
-
 
580
                                        h->signer_digest = cxml_tag_attr_value(tag, "digest");
-
 
581
                                        if (h->signer_type == si_digest_with_other_algorithm){
-
 
582
                                                int alg;
-
 
583
                                                v = cxml_tag_attr_value(tag, "algorithm");
-
 
584
                                                if (v == NULL) {
-
 
585
                                                        fprintf(stderr, "Signing algorithm shall be provided\n");
-
 
586
                                                        return -1;
-
 
587
                                                }
-
 
588
                                                alg = STR2ENUM(_pk_algorithms, v);
-
 
589
                                                if (alg < 0){
-
 
590
                                                        fprintf(stderr, "%s: Unknown public key algorithm\n", v);
-
 
591
                                                        return -1;
-
 
592
                                                }
-
 
593
                                                cint8_write(alg, &h->ptr, h->end, &rc);
-
 
594
                                        }
-
 
595
                                }
-
 
596
                                if (h->signer_digest == NULL){
520
                                v = cxml_tag_attr_value(tag, "name");
597
                                        v = cxml_tag_attr_value(tag, "name");
521
                                if (v == NULL){
598
                                        if (v == NULL){
522
                                        fprintf(stderr, "%s: Signer name shall be provided\n", v);
599
                                                fprintf(stderr, "%s: Signer name or digest shall be provided\n", v);
523
                                        return -1;
600
                                                return -1;
524
                                }
601
                                        }
525
                                h->signer = v;
602
                                        h->signer = v;
-
 
603
                                }
-
 
604
                        }
-
 
605
                        if (h->signer_type == si_certificate_chain ||
-
 
606
                                h->signer_type >= si_other){
-
 
607
                                bookmark_position(h, tag);
526
                        }
608
                        }
527
                }
609
                }
528
        }else{
610
        }else{
529
                // write signer info
611
                // write signer info
530
                if (h->signer_type > 0){
612
                if (h->signer_type > si_self){
-
 
613
                        if (h->signer_type < si_other) {
531
                        if (h->signer_type > 2){
614
                                if (h->signer_digest){
-
 
615
                                        int len = strlen(h->signer_digest);
-
 
616
                                        v = cstr_hex2bin(h->ptr, h->end - h->ptr, h->signer_digest, len);
-
 
617
                                        if (v == NULL){
532
                                fprintf(stderr, "%d: signer method unsupported\n", h->signer_type);
618
                                                fprintf(stderr, "%s: no more space to write digest of size %d bytes\n", v, len);
533
                                rc = -1;
619
                                                return -1;
-
 
620
                                        }
534
                        }
621
                                }
535
                        else{
622
                                else{
-
 
623
                                        char * path, *cname;
-
 
624
                                        int plen;
-
 
625
                                        cname = (char*)h->signer;
-
 
626
                                        while (*cname){
-
 
627
                                                char * se = strchr(cname, ' ');
-
 
628
                                                if (se){
-
 
629
                                                        *se = 0;
-
 
630
                                                        while (cisspace(*se))se++;
-
 
631
                                                }
-
 
632
                                                else se = cstrend(cname);
-
 
633
                                                h->signer = cname;
-
 
634
536
                                // load signer certificate
635
                                                // load signer certificate
537
                                int plen = strlen(_searchPath) + strlen(h->signer);
636
                                                plen = strlen(_searchPath) + (se - cname);
538
                                char * path = malloc(plen + 16);
637
                                                path = malloc(plen + 16);
539
                                cvstrncpy(path, plen + 16, _searchPath, "/", h->signer, ".crt", NULL);
638
                                                cvstrncpy(path, plen + 16, _searchPath, "/", cname, ".crt", NULL);
540
                                size_t size = load_certificate(path, h->ptr, h->end);
639
                                                size_t size = load_certificate(path, h->ptr, h->end);
541
                                if (size < 0){
640
                                                if (size < 0){
542
                                        fprintf(stderr, "%s: signer certificate not found or error\n", h->signer);
641
                                                        fprintf(stderr, "%s: signer certificate not found or error\n", h->signer);
543
                                        rc = -1;
642
                                                        rc = -1;
544
                                }
643
                                                }
545
                                else{
644
                                                else{
-
 
645
                                                        // digests
546
                                        if (h->signer_type == 1){ // digest
646
                                                        if (h->signer_type == si_digest || h->signer_type == si_digest_with_other_algorithm){
547
                                                char hash[sha256_hash_size];
647
                                                                char hash[sha256_hash_size];
548
                                                // change eccpoint type of the signature to x_coordinate_only(0) 
648
                                                                // change eccpoint type of the signature to x_coordinate_only(0) 
549
                                                // to follow canonical encoding
649
                                                                // to follow canonical encoding
550
                                                h->ptr[size-65] = 0;
650
                                                                h->ptr[size - 65] = 0;
551
                                                sha256_calculate(hash, h->ptr, size);
651
                                                                sha256_calculate(hash, h->ptr, size);
Line 557... Line 657...
557
                                                print_x(stderr, &hash[sha256_hash_size - 8], 8);
657
                                                                print_x(stderr, &hash[sha256_hash_size - 8], 8);
558
                                                fprintf(stderr, "\n");
658
                                                                fprintf(stderr, "\n");
559
#endif
659
#endif
560
                                                cbuf_write(hash + sha256_hash_size - 8, 8, &h->ptr, h->end, &rc);
660
                                                                cbuf_write(hash + sha256_hash_size - 8, 8, &h->ptr, h->end, &rc);
561
                                        }
661
                                                        }
562
                                        else {// certificate
662
                                                        else {// certificate or chain
563
                                                h->ptr += size;
663
                                                                h->ptr += size;
-
 
664
                                                                if (h->signer_type == si_certificate_chain){
-
 
665
                                                                        cname = se;
-
 
666
                                                                        continue;
564
                                        }
667
                                                                }
-
 
668
                                                        }
-
 
669
                                                }
-
 
670
                                                // continue only if certificate chain
-
 
671
                                                break;
565
                                }
672
                                        }
566
                                free(path);
673
                                        free(path);
-
 
674
                                }
-
 
675
                        }
-
 
676
                        if (h->signer_type == si_certificate_chain || h->signer_type >= si_other) {
-
 
677
                                apply_bookmark_size(h, tag);
567
                        }
678
                        }
568
                }
679
                }
569
        }
680
        }
570
        return rc;
681
        return rc;
571
}
682
}
572
683
573
static int certificate_signer_text(cxml_handler_t* const h, char * const text, int length)
684
static int certificate_signer_text(cxml_handler_t* const _h, char * const text, int length)
-
 
685
{
-
 
686
        int rc = 0;
-
 
687
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
-
 
688
        if (h->signer_type >= si_other) {
-
 
689
                cbuf_write(text, length, &h->ptr, h->end, &rc);
-
 
690
        }
574
{ return 0;}
691
        return rc;
-
 
692
}
575
693
576
static const char * _subject_type [] = {
694
static const char * _subject_type [] = {
577
        "EC",   "AT",   "AA",   "EA",   "ROOT", "CRL"
695
        "EC",   "AT",   "AA",   "EA",   "ROOT", "CRL"
578
};
696
};
579
697
Line 687... Line 805...
687
                }
805
                }
688
                h->sa_type = -1;
806
                h->sa_type = -1;
689
        }
807
        }
690
        return rc;
808
        return rc;
691
}
809
}
692
-
 
693
static const char * _pk_algorithms[] = {
-
 
694
        [0]  = "ecdsa_nistp256_with_sha256",
-
 
695
        [1]  = "ecies_nistp256",
-
 
696
};
-
 
697
-
 
698
static const char * _sym_algorithms[] = {
-
 
699
        [0]  = "aes_128_ccm",
-
 
700
};
-
 
701
static const char * _point_types [] = {
-
 
702
        [0] = "x_coordinate_only",
-
 
703
        [1] = "compressed",
-
 
704
        [2] = "compressed_y0",
-
 
705
        [3] = "compressed_y1",
-
 
706
        [4] = "uncompressed"
-
 
707
};
-
 
708
810
709
static int attribute_public_key_tag(cxml_handler_t* const _h, cxml_tag_t * const tag)
811
static int attribute_public_key_tag(cxml_handler_t* const _h, cxml_tag_t * const tag)
710
{
812
{
711
        int rc = 0;
813
        int rc = 0;
712
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
814
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
Line 846... Line 948...
846
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
948
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
847
        if (cxml_tag_is_open(tag)){
949
        if (cxml_tag_is_open(tag)){
848
                uint8_t assurance = 0;
950
                uint8_t assurance = 0;
849
                const char * v = cxml_tag_attr_value(tag, "level");
951
                const char * v = cxml_tag_attr_value(tag, "level");
850
                if(v){
952
                if(v){
851
                        while(*v && isspace(*v))v++;
953
                        while(*v && cisspace(*v))v++;
852
                        if(*v){
954
                        if(*v){
853
                                long n = strtol(v, NULL, 0);
955
                                long n = strtol(v, NULL, 0);
854
                                if(n<0 || n > 7){
956
                                if(n<0 || n > 7){
855
                                        fprintf(stderr, "%s: Invalid assurance level\n", v);
957
                                        fprintf(stderr, "%s: Invalid assurance level\n", v);
856
                                        return -1;
958
                                        return -1;
Line 858... Line 960...
858
                                assurance |= n<<5;
960
                                assurance |= n<<5;
859
                        }
961
                        }
860
                }
962
                }
861
                v = cxml_tag_attr_value(tag, "confidence");
963
                v = cxml_tag_attr_value(tag, "confidence");
862
                if(v){
964
                if(v){
863
                        while(*v && isspace(*v))v++;
965
                        while(*v && cisspace(*v))v++;
864
                        if(*v){
966
                        if(*v){
865
                                long n = strtol(v, NULL, 0);
967
                                long n = strtol(v, NULL, 0);
866
                                if(n<0 || n > 3){
968
                                if(n<0 || n > 3){
867
                                        fprintf(stderr, "%s: Invalid assurance confidence\n", v);
969
                                        fprintf(stderr, "%s: Invalid assurance confidence\n", v);
868
                                        return -1;
970
                                        return -1;
Line 884... Line 986...
884
                if(NULL == v)v = cxml_tag_attr_value(tag, "aid");
986
                if(NULL == v)v = cxml_tag_attr_value(tag, "aid");
885
                if(NULL == v){
987
                if(NULL == v){
886
                        fprintf(stderr, "WARNING: Value required for AID tag. Item was skiped.\n");
988
                        fprintf(stderr, "WARNING: Value required for AID tag. Item was skiped.\n");
887
                }else{
989
                }else{
888
                        uint32_t n;
990
                        uint32_t n;
889
                        while(isspace(*v))v++;
991
                        while(cisspace(*v))v++;
890
                        if(!isdigit(*v)){
992
                        if(!cisdigit(*v)){
891
                                fprintf(stderr, "ERROR: Invalid AID '%s'\n", v);
993
                                fprintf(stderr, "ERROR: Invalid AID '%s'\n", v);
892
                                rc = -1;
994
                                rc = -1;
893
                        }else{
995
                        }else{
894
                                n = strtoul(v, NULL, 0);
996
                                n = strtoul(v, NULL, 0);
895
                                cintx_write(n, &h->ptr, h->end, &rc);
997
                                cintx_write(n, &h->ptr, h->end, &rc);
Line 908... Line 1010...
908
                const char * v = cxml_tag_attr_value(tag, "aid");
1010
                const char * v = cxml_tag_attr_value(tag, "aid");
909
                if(NULL == v){
1011
                if(NULL == v){
910
                        fprintf(stderr, "ERROR: AID shall be supplied for SSP.\n");
1012
                        fprintf(stderr, "ERROR: AID shall be supplied for SSP.\n");
911
                        return -1;
1013
                        return -1;
912
                }
1014
                }
913
                while(isspace(*v))v++;
1015
                while(cisspace(*v))v++;
914
                if(!isdigit(*v)){
1016
                if(!cisdigit(*v)){
915
                        fprintf(stderr, "ERROR: Invalid AID '%s' in SSP\n", v);
1017
                        fprintf(stderr, "ERROR: Invalid AID '%s' in SSP\n", v);
916
                        return -1;
1018
                        return -1;
917
                }
1019
                }
918
                n = strtoul(v, NULL, 0);
1020
                n = strtoul(v, NULL, 0);
919
                cintx_write(n, &h->ptr, h->end, &rc);
1021
                cintx_write(n, &h->ptr, h->end, &rc);
Line 946... Line 1048...
946
                rc = apply_bookmark_size(h, tag);
1048
                rc = apply_bookmark_size(h, tag);
947
        }
1049
        }
948
        return rc;
1050
        return rc;
949
}
1051
}
950
1052
951
static unsigned int _convert_time(const char * v)
1053
static unsigned int _convert_diff_time(const char * v)
952
{
1054
{
953
        unsigned int ret;
1055
        unsigned int ret = 0;
-
 
1056
        const char * p = v;
954
        char * e;
1057
        char * e;
955
        struct tm tm;
1058
        int mult = 1;
956
       
-
 
957
        // can me a difference of the predefined point in time
-
 
958
        if(*v == '-' || *v == '+'){
1059
        switch (*p){
959
                const char * p;
1060
        case '-':
960
                if(_defaultTime == 0){
1061
                mult = -1;
961
                        fprintf(stderr, "Default time must be set\n");
1062
        case '+':
962
                        return 0;
1063
                p++;
963
                }
1064
        }
964
                p = v+1;
-
 
965
                ret = 0;
1065
966
                for(;;){
1066
        for (;;){
967
                        unsigned int n;
1067
                unsigned int n;
968
                        n = strtoul(p, &e, 10);
1068
                n = strtoul(p, &e, 10);
969
                        if(n == ULONG_MAX) break;
1069
                if (n == ULONG_MAX) break;
-
 
1070
                if (cisalnum(*e)){
970
                        switch(*e){
1071
                        switch (*e){
971
                        case 'd': n *= 24;
1072
                        case 'd': n *= 24;
972
                        case 'h': n *= 60;
1073
                        case 'h': n *= 60;
973
                        case 'm': n *= 60;
1074
                        case 'm': n *= 60;
974
                        case 's': e++;
1075
                        case 's': e++; break;
-
 
1076
                        default:
-
 
1077
                                fprintf(stderr, "%s: Unknown time modificator: '%c'\n", p, *e);
-
 
1078
                                return INT32_MIN;
-
 
1079
                        }
-
 
1080
                }
-
 
1081
                else{
-
 
1082
                        // consider n as days
-
 
1083
                        n *= 24 * 3600;
975
                        }
1084
                }
976
                        ret += n;
1085
                ret += n;
977
                        if(isdigit(*e)){
1086
                if (cisdigit(*e)){
978
                                p = e;
1087
                        p = e;
979
                                continue;
1088
                        continue;
980
                        }
1089
                }
981
                        break;
1090
                break;
982
                }
1091
        }
983
                if(*v == '-'){
-
 
984
                        ret = _defaultTime - ret;
-
 
985
                }else{
-
 
986
                        ret = _defaultTime + ret;
1092
        return ret * mult;
987
                }
1093
}
-
 
1094
-
 
1095
static unsigned int _convert_time2(const char * v, unsigned int baseTime)
-
 
1096
{
-
 
1097
        unsigned int ret;
-
 
1098
        char * e;
-
 
1099
        struct tm tm;
-
 
1100
       
-
 
1101
        // can be a difference from the base time point
-
 
1102
        if (*v == '-' || *v == '+'){
-
 
1103
                if (baseTime == 0){
-
 
1104
                        fprintf(stderr, "Default time must be set\n");
-
 
1105
                        return 0;
-
 
1106
                }
-
 
1107
                ret = _convert_diff_time(v);
-
 
1108
                if (ret == INT32_MIN)
-
 
1109
                        return 0;
-
 
1110
                ret = baseTime + ret;
988
        }
1111
        }
989
        else{
1112
        else{
990
                // next try load as integer seconds since epoch
1113
                // next try load as integer seconds since epoch
991
                ret = strtoul(v, &e, 0);
1114
                ret = strtoul(v, &e, 0);
992
                if (ret == ULONG_MAX || *e){
1115
                if (ret == ULONG_MAX || *e){
993
                        ret = 0;
1116
                        ret = 0;
994
                        //next try to convert ISO text representation
-
 
995
                        memset(&tm, 0, sizeof(tm));
1117
                        memset(&tm, 0, sizeof(tm));
-
 
1118
                        // check predefined values
-
 
1119
                        if ((e = cstrisprefix(v, "today"))){
-
 
1120
                                time_t t;
-
 
1121
                                struct tm * ptm;
-
 
1122
                                time(&t); ptm = gmtime(&t);
-
 
1123
                                tm.tm_year = ptm->tm_year; tm.tm_mon = ptm->tm_mon; tm.tm_mday = ptm->tm_mday;
-
 
1124
                        }
-
 
1125
                        else if ((e = cstrisprefix(v, "ybegin"))){
-
 
1126
                                time_t t;
-
 
1127
                                struct tm * ptm;
-
 
1128
                                time(&t); ptm = gmtime(&t);
-
 
1129
                                tm.tm_year = ptm->tm_year; tm.tm_mon = 0; tm.tm_mday = 1;
-
 
1130
                        }
-
 
1131
                        else if ((e = cstrisprefix(v, "yend"))){
-
 
1132
                                time_t t;
-
 
1133
                                struct tm * ptm;
-
 
1134
                                time(&t); ptm = gmtime(&t);
-
 
1135
                                tm.tm_year = ptm->tm_year+1; tm.tm_mon = 0; tm.tm_mday = 1;
-
 
1136
                        }
-
 
1137
                        //next try to convert ISO text representation
996
                        if (3 == sscanf(v, "%d-%d-%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday)){
1138
                        else if (3 == sscanf(v, "%d-%d-%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday)){
997
                                tm.tm_mon--; // STARTED FROM 0
1139
                                tm.tm_mon--; // STARTED FROM 0
998
                                if (tm.tm_year > 500){
1140
                                if (tm.tm_year > 500)
999
                                        tm.tm_year -= 1900;
1141
                                        tm.tm_year -= 1900;
-
 
1142
                                e = (char*)v; // to prevent next check for '-/+'
-
 
1143
                        }
-
 
1144
                        else{
-
 
1145
                                fprintf(stderr, "%s: Date format specification error. Use YYY-MM-DD or today+/-NNNd\n", v);
-
 
1146
                                return 0;
1000
                                }
1147
                        }
1001
                                ret = mkitstime32(&tm);
1148
                        ret = mkitstime32(&tm);
1002
                                if (ret == (time_t)-1) {
1149
                        if (ret == (time_t)-1) {
1003
                                        fprintf(stderr, "%s: Date format specification error. Use YYY-MM-DD\n", v);
1150
                                fprintf(stderr, "%s: Date format specification error. Use YYY-MM-DD or today+/-NNNd\n", v);
1004
                                        ret = 0;
1151
                                ret = 0;
1005
                                }
1152
                        }
-
 
1153
                        if (*e == '-' || *e == '+'){
-
 
1154
                                ret = _convert_time2(e, ret);
1006
                        }
1155
                        }
1007
                }
1156
                }
1008
        }
1157
        }
1009
        return ret;
1158
        return ret;
-
 
1159
}
-
 
1160
-
 
1161
static unsigned int _convert_time(const char * v)
-
 
1162
{
-
 
1163
        return _convert_time2(v, _defaultTime);
1010
}
1164
}
1011
1165
1012
static int validity_restriction_tag (cxml_handler_t* const _h, cxml_tag_t * const tag)
1166
static int validity_restriction_tag (cxml_handler_t* const _h, cxml_tag_t * const tag)
1013
{
1167
{
1014
        int rc = 0;
1168
        int rc = 0;
Line 1021... Line 1175...
1021
                if(NULL == v){
1175
                if(NULL == v){
1022
                        fprintf(stderr, "ERROR: Restriction shall have a type.\n");
1176
                        fprintf(stderr, "ERROR: Restriction shall have a type.\n");
1023
                        return -1;
1177
                        return -1;
1024
                }
1178
                }
1025
               
1179
               
1026
                while(isspace(*v))v++;
1180
                while(cisspace(*v))v++;
1027
                if(0 == strcmp("time", v)){
1181
                if(0 == strcmp("time", v)){
1028
                        start    = cxml_tag_attr_value(tag, "start");
1182
                        start    = cxml_tag_attr_value(tag, "start");
1029
                        end      = cxml_tag_attr_value(tag, "end");
1183
                        end      = cxml_tag_attr_value(tag, "end");
1030
                        duration = cxml_tag_attr_value(tag, "duration");
1184
                        duration = cxml_tag_attr_value(tag, "duration");
1031
                        if(end && *end){
1185
                        if(end && *end){
Line 1036... Line 1190...
1036
                                fprintf(stderr, "ERROR: Either end or start and duration shall be specified for time restriction.\n");
1190
                                fprintf(stderr, "ERROR: Either end or start and duration shall be specified for time restriction.\n");
1037
                                return -1;
1191
                                return -1;
1038
                        }
1192
                        }
1039
                }else if(0 == strcmp("region", v)){
1193
                }else if(0 == strcmp("region", v)){
1040
                        vr_type = 3;
1194
                        vr_type = 3;
1041
                }else if(isdigit(*v)){
1195
                }else if(cisdigit(*v)){
1042
                        vr_type=strtoul(v, NULL,0);
1196
                        vr_type=strtoul(v, NULL,0);
1043
                }else{
1197
                }else{
1044
                        fprintf(stderr, "%s: Unknown validity restriction type.\n", v);
1198
                        fprintf(stderr, "%s: Unknown validity restriction type.\n", v);
1045
                        return -1;
1199
                        return -1;
1046
                }
1200
                }
Line 1057... Line 1211...
1057
                        cint32_write(nTime, &h->ptr, h->end, &rc);
1211
                        cint32_write(nTime, &h->ptr, h->end, &rc);
1058
                        break;
1212
                        break;
1059
                case 2: /* time_start_and_duration */
1213
                case 2: /* time_start_and_duration */
1060
                        nTime = _convert_time(start);
1214
                        nTime = _convert_time(start);
1061
                        cint32_write(nTime, &h->ptr, h->end, &rc);
1215
                        cint32_write(nTime, &h->ptr, h->end, &rc);
1062
                        nTime = _convert_time(duration);
1216
                        nTime = _convert_diff_time(duration);
1063
                        cint32_write(nTime, &h->ptr, h->end, &rc);
1217
                        cint32_write(nTime, &h->ptr, h->end, &rc);
1064
                        break;
1218
                        break;
1065
                case 3: /* region */
1219
                case 3: /* region */
1066
                        break;
1220
                        break;
1067
                default: // opaque
1221
                default: // opaque
Line 1094... Line 1248...
1094
                        //latitude and longitude
1248
                        //latitude and longitude
1095
                        rc = location_tag (_h, tag);
1249
                        rc = location_tag (_h, tag);
1096
                        if(0 == rc){
1250
                        if(0 == rc){
1097
                                //radius
1251
                                //radius
1098
                                uint32_t n;
1252
                                uint32_t n;
-
 
1253
                                char * e;
1099
                                const char * v    = cxml_tag_attr_value(tag, "radius");
1254
                                const char * v    = cxml_tag_attr_value(tag, "radius");
1100
                                if(NULL == v){
1255
                                if(NULL == v){
1101
                                        fprintf(stderr, "ERROR: radius shall be specified for circle.\n");
1256
                                        fprintf(stderr, "ERROR: radius shall be specified for circle.\n");
1102
                                        return -1;
1257
                                        return -1;
1103
                                }
1258
                                }
1104
                                n = strtoul(v, NULL, 0);
1259
                                n = strtoul(v, &e, 0);
-
 
1260
                                if( (e[0] == 'k' || e[0] == 'K') && (e[1] == 'm' || e[1] == 'M') )
-
 
1261
                                        n *= 1000;
1105
                                if(n > 0xFFFF){
1262
                                if(n > 0xFFFF){
1106
                                        fprintf(stderr, "ERROR: %ul: radius is too big.\n", n);
1263
                                        fprintf(stderr, "ERROR: %ul: radius is too big.\n", n);
1107
                                        return -1;
1264
                                        return -1;
1108
                                }
1265
                                }
1109
                                cint16_write(n, &h->ptr, h->end, &rc);
1266
                                cint16_write(n, &h->ptr, h->end, &rc);
Line 1147... Line 1304...
1147
1304
1148
static int location_tag (cxml_handler_t* const _h, cxml_tag_t * const tag)
1305
static int location_tag (cxml_handler_t* const _h, cxml_tag_t * const tag)
1149
{
1306
{
1150
        int rc = 0;
1307
        int rc = 0;
1151
        if (cxml_tag_is_open(tag)){
1308
        if (cxml_tag_is_open(tag)){
1152
                int32_t lat, lon;
1309
                int32_t lat, lon, absolute = 0;
1153
                long double d;
1310
                long double d;
-
 
1311
                char * e;
1154
                cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
1312
                cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
-
 
1313
1155
                const char * v    = cxml_tag_attr_value(tag, "latitude");
1314
                const char * v = cxml_tag_attr_value(tag, "mode");
-
 
1315
                absolute = cstrequal(v, "absolute");
-
 
1316
                       
-
 
1317
                v = cxml_tag_attr_value(tag, "latitude");
-
 
1318
                int relative = 1;
1156
                if(v == NULL){
1319
                if(v == NULL){
1157
                        fprintf(stderr, "ERROR: Latitude shall be specified for location.\n");
1320
                        fprintf(stderr, "ERROR: Latitude must be specified for location.\n");
1158
                        return -1;
1321
                        return -1;
1159
                }
1322
                }
1160
                d = strtold(v, NULL);
1323
                e = NULL; d = strtold(v, &e);
-
 
1324
                if(e[0] == 'm' || (e[0] == 'k' && e[1] == 'm')){
-
 
1325
                        if(e[0] == 'k') d*=1000.0;
-
 
1326
                        d = d * _latTMDPerMetter;
-
 
1327
                }else{
1161
                if (d <= 90.0 &&  d >= -90.0) d *= 10000000.0; // degree
1328
                        if (d <= 90.0 &&  d >= -90.0) d *= 10000000.0; // degree
-
 
1329
                }
-
 
1330
                if (!absolute) d += _refLat;
1162
                lat = (int32_t)floorl(d+_refLat);
1331
                lat = (int32_t)floorl(d);
1163
1332
1164
                v    = cxml_tag_attr_value(tag, "longitude");
1333
                v    = cxml_tag_attr_value(tag, "longitude");
1165
                if(v == NULL){
1334
                if(v == NULL){
1166
                        fprintf(stderr, "ERROR: Longitude shall be specified for location.\n");
1335
                        fprintf(stderr, "ERROR: Longitude shall be specified for location.\n");
1167
                        return -1;
1336
                        return -1;
1168
                }
1337
                }
1169
                d = strtold(v, NULL);
1338
                e = NULL; d = strtold(v, &e);
-
 
1339
                if(e[0] == 'm' || (e[0] == 'k' && e[1] == 'm')){
-
 
1340
                        if(e[0] == 'k') d*=1000.0;
-
 
1341
                        // convert metters to degree
-
 
1342
                        d = d * _lonTMDPerMetter;
-
 
1343
                }else{
1170
                if (d <= 180.0 &&  d >= -180.0) d *= 10000000.0; // degree
1344
                        if (d <= 180.0 &&  d >= -180.0) d *= 10000000.0; // degree
-
 
1345
                }
-
 
1346
                if (!absolute) d += _refLon;
1171
                lon = (int32_t)floorl(d + _refLon);
1347
                lon = (int32_t)floorl(d);
1172
1348
1173
                cint32_write(lat, &h->ptr, h->end, &rc);
1349
                cint32_write(lat, &h->ptr, h->end, &rc);
1174
                cint32_write(lon, &h->ptr, h->end, &rc);
1350
                cint32_write(lon, &h->ptr, h->end, &rc);
1175
        }
1351
        }
1176
        return rc;
1352
        return rc;
Line 1210... Line 1386...
1210
                v = cxml_tag_attr_value(tag, "id");
1386
                v = cxml_tag_attr_value(tag, "id");
1211
                if(v == NULL){
1387
                if(v == NULL){
1212
                        fprintf(stderr, "ERROR: Region identifier must be set\n");
1388
                        fprintf(stderr, "ERROR: Region identifier must be set\n");
1213
                        return -1;
1389
                        return -1;
1214
                }
1390
                }
1215
                while(isspace(*v))v++;
1391
                while(cisspace(*v))v++;
1216
                uvalue = strtoul(v, NULL, 0);
1392
                uvalue = strtoul(v, NULL, 0);
1217
                if(uvalue > 0xFFFF){
1393
                if(uvalue > 0xFFFF){
1218
                        fprintf(stderr, "%s: Invalid region identifier\n", v);
1394
                        fprintf(stderr, "%s: Invalid region identifier\n", v);
1219
                        return -1;
1395
                        return -1;
1220
                }
1396
                }
Line 1223... Line 1399...
1223
                }
1399
                }
1224
                       
1400
                       
1225
                uvalue = 0;
1401
                uvalue = 0;
1226
                v = cxml_tag_attr_value(tag, "local");
1402
                v = cxml_tag_attr_value(tag, "local");
1227
                if(v){
1403
                if(v){
1228
                        while(isspace(*v))v++;
1404
                        while(cisspace(*v))v++;
1229
                        uvalue = strtoul(v, NULL, 0);
1405
                        uvalue = strtoul(v, NULL, 0);
1230
                        if(!isdigit(*v) || uvalue > 0xFFFF){
1406
                        if(!cisdigit(*v) || uvalue > 0xFFFF){
1231
                                fprintf(stderr, "%s: Invalid region identifier\n", v);
1407
                                fprintf(stderr, "%s: Invalid region identifier\n", v);
1232
                                return -1;
1408
                                return -1;
1233
                        }
1409
                        }
1234
                }
1410
                }
1235
                cintx_write(uvalue, &h->ptr, h->end, &rc);
1411
                cintx_write(uvalue, &h->ptr, h->end, &rc);
1236
                if(rc) return -1;
1412
                if(rc) return -1;
1237
        }
1413
        }
1238
        return rc;
1414
        return rc;
-
 
1415
}
-
 
1416
-
 
1417
static const char * _region_types[] = {
-
 
1418
        [0] = "none",
-
 
1419
        [1] = "circle",
-
 
1420
        [2] = "rectangle",
-
 
1421
        [3] = "polygon",
-
 
1422
        [4] = "id"
-
 
1423
};
-
 
1424
static cxml_tag_f* _region_type_handlers[] = {
-
 
1425
        [0] = region_none_tag,
-
 
1426
        [1] = region_circle_tag,
-
 
1427
        [2] = region_rectangle_tag,
-
 
1428
        [3] = region_polygon_tag,
-
 
1429
        [4] = region_id_tag
-
 
1430
};
-
 
1431
-
 
1432
static int region_region_tag(cxml_handler_t* const _h, cxml_tag_t * const tag)
-
 
1433
{
-
 
1434
        int rc = 0;
-
 
1435
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
-
 
1436
        if (cxml_tag_is_open(tag)){
-
 
1437
                const char * v;
-
 
1438
                v = cxml_tag_attr_value(tag, "type");
-
 
1439
                h->nTmpValue = STR2ENUM(_region_types, v);
-
 
1440
                if (h->nTmpValue < 0){
-
 
1441
                        fprintf(stderr, "ERROR: unknown region type: %s\n", v);
-
 
1442
                        return -1;
-
 
1443
                }
-
 
1444
        }
-
 
1445
        if (h->nTmpValue < sizeof(_region_type_handlers) / sizeof(_region_type_handlers[0])){
-
 
1446
                return _region_type_handlers[h->nTmpValue](_h, tag);
-
 
1447
        }
-
 
1448
-
 
1449
        if (cxml_tag_is_open(tag)){
-
 
1450
                // region type
-
 
1451
                rc = cint8_write(h->nTmpValue, &h->ptr, h->end, NULL);
-
 
1452
                bookmark_position(h, tag);
-
 
1453
        } else{
-
 
1454
                apply_bookmark_size(h, tag);
-
 
1455
        }
-
 
1456
        return rc;
-
 
1457
}
-
 
1458
-
 
1459
static int region_region_text(cxml_handler_t* const _h, char * const text, int length)
-
 
1460
{
-
 
1461
        cert_cxml_handler_t * h = (cert_cxml_handler_t *)_h;
-
 
1462
        char * end;
-
 
1463
        // try to treat it as hex
-
 
1464
        end = cstr_hex2bin(h->ptr, h->end - h->ptr, text, length);
-
 
1465
        if (end){
-
 
1466
                h->ptr = end;
-
 
1467
        }
-
 
1468
        else{
-
 
1469
                if (length > (h->end - h->ptr)){
-
 
1470
                        fprintf(stderr, "ERROR: region definition is tooooo big: %d bytes\n", length);
-
 
1471
                        return -1;
-
 
1472
                }
-
 
1473
                h->ptr = cmemcpy(h->ptr, text, length);
-
 
1474
        }
-
 
1475
        return 0;
1239
}
1476
}
1240
1477
1241
static const char * _signature_algorithms[] = {
1478
static const char * _signature_algorithms[] = {
1242
        "ecdsa_nistp256_with_sha256",
1479
        "ecdsa_nistp256_with_sha256",
1243
};
1480
};