rpmasn rpmasnNew(const char * fn, int flags)
{
rpmasn asn = rpmasnGetPool(_rpmasnPool);
int xx;
if (fn)
asn->fn = xstrdup(fn);
#if defined(WITH_LIBTASN1)
asn->tree = ASN1_TYPE_EMPTY;
xx = asn1_parser2tree(fn, &asn->tree, asn->error);
/* XXX errors. */
#endif
return rpmasnLink(asn);
}
int
main (int argc, char *argv[])
{
int result, der_len;
unsigned char der[1024];
ASN1_TYPE PKIX1Implicit88 = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
if (1)
result =
asn1_array2tree (pkix_asn1_tab, &PKIX1Implicit88, errorDescription);
else
result =
asn1_parser2tree ("pkix.asn", &PKIX1Implicit88, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("%s", errorDescription);
exit (1);
}
/* Use the following 3 lines to visit the PKIX1Implicit structures */
/* printf("-----------------\n");
asn1_visit_tree(PKIX1Implicit88,"PKIX1Implicit88");
printf("-----------------\n"); */
der_len = 1024;
create_certificate (PKIX1Implicit88, der, &der_len);
get_certificate (PKIX1Implicit88, der, der_len);
/* Clear the "PKIX1Implicit88" structures */
asn1_delete_structure (&PKIX1Implicit88);
return 0;
}
int
main (int argc, char** argv)
{
int result = 0;
asn1_node definitions = NULL, node1 = NULL, node2 = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
const char *choicefile = getenv ("ASN1CHOICE");
char data[1024];
int data_size = sizeof (data);
if (!choicefile)
choicefile = "pkix.asn";
/* Encode */
result = asn1_parser2tree (choicefile, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
result = asn1_create_element (definitions, "TEST.Choice0", &node1);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
result = asn1_write_value (node1, "", "choice1", 1);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
result = asn1_write_value (node1, "choice1", "choice2", 1);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
result = asn1_write_value (node1, "choice1.choice2", "int1", 1);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
result = asn1_write_value (node1, "choice1.choice2.int1", "1234", 0);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
result = asn1_der_coding (node1, "", data, &data_size, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
asn1_delete_structure (&node1);
/* Decode */
result = asn1_create_element (definitions, "TEST.Choice0", &node2);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
#if 0
printf ("der:");
for (i = 0; i < data_size; i++)
printf ("%.2x ", (unsigned char) (data[i]));
printf ("\n");
#endif
result = asn1_der_decoding (&node2, data, data_size, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
asn1_delete_structure (&node2);
asn1_delete_structure (&definitions);
return 0;
}
int
main (int argc, char *argv[])
{
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"check", no_argument, 0, 'c'},
{"output", required_argument, 0, 'o'},
{0, 0, 0, 0}
};
int option_index = 0;
int option_result;
char *outputFileName = NULL;
char *inputFileAsnName = NULL;
char *inputFileAssignmentName = NULL;
int checkSyntaxOnly = 0;
asn1_node definitions = NULL;
asn1_node structure = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
int asn1_result = ASN1_SUCCESS;
FILE *outputFile;
FILE *inputFile;
char varName[1024];
char value[1024];
unsigned char *der = NULL;
int der_len;
int k;
int last_ra;
set_program_name (argv[0]);
opterr = 0; /* disable error messages from getopt */
while (1)
{
option_result =
getopt_long (argc, argv, "hvco:", long_options, &option_index);
if (option_result == -1)
break;
switch (option_result)
{
case 'h': /* HELP */
free (outputFileName);
usage (EXIT_SUCCESS);
break;
case 'v': /* VERSION */
version_etc (stdout, program_name, PACKAGE, VERSION,
"Fabio Fiorina", NULL);
free (outputFileName);
exit (0);
break;
case 'c': /* CHECK SYNTAX */
checkSyntaxOnly = 1;
break;
case 'o': /* OUTPUT */
outputFileName = (char *) malloc (strlen (optarg) + 1);
strcpy (outputFileName, optarg);
break;
case '?': /* UNKNOW OPTION */
free (outputFileName);
fprintf (stderr,
"asn1Coding: option '%s' not recognized or without argument.\n\n",
argv[optind - 1]);
usage (EXIT_FAILURE);
break;
default:
fprintf (stderr,
"asn1Coding: ?? getopt returned character code Ox%x ??\n",
option_result);
}
}
if (optind == argc || optind == argc - 1)
{
free (outputFileName);
fputs ("asn1Coding: input files missing\n", stderr);
usage (EXIT_FAILURE);
}
inputFileAsnName = (char *) malloc (strlen (argv[optind]) + 1);
strcpy (inputFileAsnName, argv[optind]);
inputFileAssignmentName = (char *) malloc (strlen (argv[optind + 1]) + 1);
strcpy (inputFileAssignmentName, argv[optind + 1]);
asn1_result =
asn1_parser2tree (inputFileAsnName, &definitions, errorDescription);
switch (asn1_result)
{
case ASN1_SUCCESS:
fputs ("Parse: done.\n", stderr);
break;
case ASN1_FILE_NOT_FOUND:
fprintf (stderr, "asn1Coding: FILE %s NOT FOUND\n", inputFileAsnName);
break;
case ASN1_SYNTAX_ERROR:
case ASN1_IDENTIFIER_NOT_FOUND:
case ASN1_NAME_TOO_LONG:
fprintf (stderr, "asn1Coding: %s\n", errorDescription);
break;
default:
fprintf (stderr, "libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
}
if (asn1_result != ASN1_SUCCESS)
{
free (inputFileAsnName);
free (inputFileAssignmentName);
exit (1);
}
inputFile = fopen (inputFileAssignmentName, "r");
if (inputFile == NULL)
{
fprintf (stderr, "asn1Coding: file '%s' not found\n",
inputFileAssignmentName);
free (inputFileAsnName);
free (inputFileAssignmentName);
exit (1);
}
putc ('\n', stderr);
while ((last_ra = readAssignment (inputFile, varName, value))
== ASSIGNMENT_SUCCESS)
{
fprintf (stderr, "var=%s, value=%s\n", varName, value);
if (structure == NULL)
{
asn1_result = asn1_create_element (definitions, value, &structure);
}
else
{
if (strcmp(value, "(NULL)") == 0)
asn1_result = asn1_write_value (structure, varName, NULL, 0);
else
asn1_result = asn1_write_value (structure, varName, value, 0);
}
if (asn1_result != ASN1_SUCCESS)
{
fprintf (stderr, "libtasn1 ERROR: %s\n",
asn1_strerror (asn1_result));
asn1_delete_structure (&definitions);
asn1_delete_structure (&structure);
free (inputFileAsnName);
free (inputFileAssignmentName);
fclose (inputFile);
exit (1);
}
}
if (last_ra != ASSIGNMENT_EOF)
{
fprintf (stderr, "asn1Coding: error reading assignment file\n");
exit (1);
}
fclose (inputFile);
putc ('\n', stderr);
asn1_print_structure (stderr, structure, "", ASN1_PRINT_NAME_TYPE_VALUE);
der_len = 0;
asn1_result = asn1_der_coding (structure, "", der, &der_len,
errorDescription);
if (asn1_result == ASN1_MEM_ERROR)
{
der = malloc (der_len);
asn1_result = asn1_der_coding (structure, "", der, &der_len,
errorDescription);
}
fprintf (stderr, "\nCoding: %s\n\n", asn1_strerror (asn1_result));
if (asn1_result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1Coding: %s\n", errorDescription);
free (der);
asn1_delete_structure (&definitions);
asn1_delete_structure (&structure);
free (inputFileAsnName);
free (inputFileAssignmentName);
exit (1);
}
/* Print the 'Certificate1' DER encoding */
fprintf (stderr, "-----------------\nNumber of bytes=%i\n", der_len);
for (k = 0; k < der_len; k++)
fprintf (stderr, "%02x ", der[k]);
fputs ("\n-----------------\n", stderr);
asn1_delete_structure (&definitions);
asn1_delete_structure (&structure);
if (!checkSyntaxOnly)
{
if (outputFileName == NULL)
createFileName (inputFileAssignmentName, &outputFileName);
fprintf (stderr, "\nOutputFile=%s\n", outputFileName);
outputFile = fopen (outputFileName, "w");
if (outputFile == NULL)
{
fprintf (stderr,
"asn1Coding: output file '%s' not available\n",
outputFileName);
free (der);
free (inputFileAsnName);
free (inputFileAssignmentName);
free (outputFileName);
exit (1);
}
for (k = 0; k < der_len; k++)
fprintf (outputFile, "%c", der[k]);
fclose (outputFile);
fputs ("\nWriting: done.\n", stderr);
}
free (der);
free (inputFileAsnName);
free (inputFileAssignmentName);
free (outputFileName);
exit (0);
}
int
main (int argc, char** argv)
{
int result = 0, len;
asn1_node definitions = NULL, node1 = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
const char *choicefile = getenv ("ASN1CHOICE_OCSP");
const char *datafile = getenv ("ASN1CHOICE_OCSP_DATA");
FILE *fp;
char data[1024];
char data2[1024];
int data_size = sizeof (data);
if (!choicefile)
choicefile = "pkix.asn";
if (!datafile)
datafile = "ocsp.der";
/* Encode */
result = asn1_parser2tree (choicefile, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("error in %d: %s\n", __LINE__, errorDescription);
exit (1);
}
result = asn1_create_element (definitions, "PKIX1.ResponseData", &node1);
if (result != ASN1_SUCCESS)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
fp = fopen(datafile, "r");
if (fp == NULL)
{
printf ("error in %d\n", __LINE__);
exit (1);
}
data_size = fread(data, 1, sizeof(data), fp);
fclose(fp);
result = asn1_der_decoding (&node1, data, data_size, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("error in %d: %s\n", __LINE__, errorDescription);
exit (1);
}
len = sizeof(data2);
result = asn1_der_coding (node1, "", data2, &len, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("error in %d: %s\n", __LINE__, errorDescription);
exit (1);
}
if (len != data_size)
{
printf ("length doesn't match (got: %d, should be: %d): known issue\n", len, data_size);
exit (77);
}
if (memcmp(data, data2, len) != 0)
{
printf ("contents don't match: known issue\n");
exit (77);
}
asn1_delete_structure (&node1);
asn1_delete_structure (&definitions);
return 0;
}
int
main (int argc, char *argv[])
{
int result;
char buffer[5 * 1024];
char buffer2[5 * 1024];
asn1_node definitions = NULL;
asn1_node asn1_element = NULL, cpy_node = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
FILE *out, *fd;
int start, end;
ssize_t size;
int size2;
const char *treefile = getenv ("ASN1PKIX");
const char *derfile = getenv ("ASN1CRLDER");
int verbose = 0;
if (argc > 1)
verbose = 1;
if (!treefile)
treefile = "pkix.asn";
if (!derfile)
derfile = "crl.der";
if (verbose)
{
printf ("\n\n/****************************************/\n");
printf ("/* Test sequence : Test_indefinite */\n");
printf ("/****************************************/\n\n");
printf ("ASN1TREE: %s\n", treefile);
}
/* Check version */
if (asn1_check_version ("0.3.3") == NULL)
printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
asn1_check_version (NULL));
result = asn1_parser2tree (treefile, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("ErrorDescription = %s\n\n", errorDescription);
exit (1);
}
out = stdout;
fd = fopen (derfile, "rb");
if (fd == NULL)
{
printf ("Cannot read file %s\n", derfile);
exit (1);
}
size = fread (buffer, 1, sizeof (buffer), fd);
if (size <= 0)
{
printf ("Cannot read from file %s\n", derfile);
exit (1);
}
fclose (fd);
result =
asn1_create_element (definitions, "PKIX1.CertificateList", &asn1_element);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot create CRL element\n");
exit (1);
}
result = asn1_der_decoding (&asn1_element, buffer, size, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot decode DER data (size %ld)\n", (long) size);
exit (1);
}
/* test asn1_copy_node */
result =
asn1_create_element (definitions, "PKIX1.CertificateList", &cpy_node);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot create CRL element\n");
exit (1);
}
result = asn1_copy_node(cpy_node, "", asn1_element, "");
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot copy node\n");
exit (1);
}
/* test whether the copied node encodes the same */
size2 = sizeof(buffer2);
result = asn1_der_coding (cpy_node, "", buffer2, &size2, NULL);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot encode data (size %ld)\n", (long) size);
exit (1);
}
if (size2 != size || memcmp(buffer, buffer2, size) != 0)
{
printf("DER encoded data differ!\n");
exit(1);
}
asn1_delete_structure (&cpy_node);
/* Test asn1_dup_node */
cpy_node = asn1_dup_node(asn1_element, "");
if (cpy_node == NULL)
{
printf ("Cannot copy node (dup_node)\n");
exit (1);
}
/* test whether the copied node encodes the same */
size2 = sizeof(buffer2);
result = asn1_der_coding (cpy_node, "", buffer2, &size2, NULL);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot encode data (size %ld)\n", (long) size);
exit (1);
}
if (size2 != size || memcmp(buffer, buffer2, size) != 0)
{
printf("DER encoded data differ!\n");
exit(1);
}
result = asn1_der_decoding_startEnd (asn1_element, buffer, size, "tbsCertList.issuer", &start, &end);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot find start End\n");
exit (1);
}
if (start != 24 && end != 291)
{
printf("Error in start and end values for issuer. Have: %d..%d\n", start, end);
exit(1);
}
result = asn1_der_decoding_startEnd (asn1_element, buffer, size, "signature", &start, &end);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot find start End\n");
exit (1);
}
if (start != 372 && end != 503)
{
printf("Error in start and end values for signature. Have: %d..%d\n", start, end);
exit(1);
}
/* Clear the definition structures */
asn1_delete_structure (&asn1_element);
asn1_delete_structure (&cpy_node);
asn1_delete_structure (&definitions);
if (out != stdout)
fclose (out);
exit (0);
}
int
main (int argc, char *argv[])
{
int result, verbose = 0;
asn1_node definitions = NULL;
asn1_node asn1_element = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
const char *treefile = getenv ("ASN1SETOF");
unsigned i;
if (argc > 1)
verbose = 1;
if (!treefile)
treefile = "setof.asn";
if (verbose != 0)
{
printf ("\n\n/****************************************/\n");
printf ("/* Test sequence : coding-decoding */\n");
printf ("/****************************************/\n\n");
}
/* Check version */
if (asn1_check_version ("0.3.3") == NULL)
printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
asn1_check_version (NULL));
result = asn1_parser2tree (treefile, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("ErrorDescription = %s\n\n", errorDescription);
exit (1);
}
result = asn1_create_element (definitions, "TEST.Set", &asn1_element);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1_create_element(): ");
asn1_perror (result);
exit (1);
}
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x00\x02", 2);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x00\x01\x00\x00", 4);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x00\x00\x00\x00", 4);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x00\x00\x00\x02", 4);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x00\x00\x00\x01", 4);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x01\x00\x00\x00", 4);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x01\x01\x00\x00", 4);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x05", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "", "NEW", 1);
assert(result == ASN1_SUCCESS);
result = asn1_write_value (asn1_element, "?LAST.val", "\x01", 1);
assert(result == ASN1_SUCCESS);
/* Clear the definition structures */
result = asn1_der_coding (asn1_element, "", data, &data_size, NULL);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "Encoding error.\n");
asn1_perror (result);
exit (1);
}
asn1_delete_structure (&asn1_element);
asn1_delete_structure (&definitions);
if (data_size != sizeof(expected_der) || memcmp(data, expected_der, data_size) != 0)
{
fprintf(stderr, "encoded data differ to expected [%d - %d]!\n", data_size, (int)sizeof(expected_der));
printf("static unsigned char got[] = {\n");
for (i=0;i<(unsigned)data_size;i++) {
printf("0x%.2x, ", (unsigned)data[i]);
if ((i+1) % 8 == 0)
printf("\n");
}
printf("};\n");
printf("static unsigned char expected[] = {\n");
for (i=0;i<(unsigned)sizeof(expected_der);i++) {
printf("0x%.2x, ", (unsigned)expected_der[i]);
if ((i+1) % 8 == 0)
printf("\n");
}
printf("};\n");
exit(1);
}
if (verbose)
printf ("Success\n");
exit (0);
}
int
main (int argc, char *argv[])
{
asn1_retCode result;
ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
ASN1_TYPE asn1_element = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
const char *treefile = getenv ("ASN1ENCODING");
if (!treefile)
treefile = "Test_encoding.asn";
printf ("\n\n/****************************************/\n");
printf ("/* Test sequence : coding-decoding */\n");
printf ("/****************************************/\n\n");
/* Check version */
if (asn1_check_version ("0.3.3") == NULL)
printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
asn1_check_version (NULL));
result = asn1_parser2tree (treefile, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("ErrorDescription = %s\n\n", errorDescription);
exit (1);
}
result = asn1_create_element (definitions, "TEST_TREE.Koko", &asn1_element);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1_create_element(): ");
asn1_perror (result);
exit (1);
}
result = asn1_write_value (asn1_element, "seqint", "NEW", 1);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1_write_value(): seqint ");
asn1_perror (result);
exit (1);
}
result = asn1_write_value (asn1_element, "seqint.?LAST", "1234", 0);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1_write_value(): seqint.?LAST ");
asn1_perror (result);
exit (1);
}
result = asn1_write_value (asn1_element, "int", "\x0f\xff\x01", 3);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1_write_value(): int ");
asn1_perror (result);
exit (1);
}
result = asn1_write_value (asn1_element, "str", "string", 6);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1_write_value(): str ");
asn1_perror (result);
exit (1);
}
/* Clear the definition structures */
asn1_delete_structure (&definitions);
result = asn1_der_coding (asn1_element, "", data, &data_size, NULL);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "Encoding error.\n");
asn1_perror (result);
exit (1);
}
result = asn1_der_decoding (&asn1_element, data, data_size, NULL);
if (result != ASN1_SUCCESS)
{
fprintf (stderr, "Decoding error.\n");
asn1_perror (result);
exit (1);
}
asn1_delete_structure (&asn1_element);
printf ("Success\n");
exit (0);
}
int
main (int argc, char *argv[])
{
asn1_retCode result;
char buffer[10 * 1024];
ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
ASN1_TYPE asn1_element = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
FILE *out, *fd;
ssize_t size;
const char *treefile = getenv ("ASN1PKIX");
const char *indeffile = getenv ("ASN1INDEF");
if (!treefile)
treefile = "pkix.asn";
if (!indeffile)
indeffile = "TestIndef.p12";
printf ("\n\n/****************************************/\n");
printf ("/* Test sequence : Test_indefinite */\n");
printf ("/****************************************/\n\n");
printf ("ASN1TREE: %s\n", treefile);
/* Check version */
if (asn1_check_version ("0.2.11") == NULL)
printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
asn1_check_version (NULL));
result = asn1_parser2tree (treefile, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("ErrorDescription = %s\n\n", errorDescription);
exit (1);
}
out = stdout;
fd = fopen (indeffile, "rb");
if (fd == NULL)
{
printf ("Cannot read file %s\n", indeffile);
exit (1);
}
size = fread (buffer, 1, sizeof (buffer), fd);
if (size <= 0)
{
printf ("Cannot read from file %s\n", indeffile);
exit (1);
}
fclose (fd);
result =
asn1_create_element (definitions, "PKIX1.pkcs-12-PFX", &asn1_element);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot create PKCS12 element\n");
exit (1);
}
result = asn1_der_decoding (&asn1_element, buffer, size, errorDescription);
if (result != ASN1_SUCCESS)
{
asn1_perror (result);
printf ("Cannot decode BER data (size %d)\n", size);
exit (1);
}
/* Clear the definition structures */
asn1_delete_structure (&definitions);
asn1_delete_structure (&asn1_element);
if (out != stdout)
fclose (out);
exit (0);
}
int
main (int argc, char *argv[])
{
asn1_retCode result;
ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
test_type *test;
int errorCounter = 0, testCounter = 0;
fileCorrectName = getenv ("ASN1PARSER");
if (!fileCorrectName)
fileCorrectName = "Test_parser.asn";
printf ("\n\n/****************************************/\n");
printf ("/* Test sequence : Test_parser */\n");
printf ("/****************************************/\n\n");
printf ("ASN1PARSER: %s\n", fileCorrectName);
result = asn1_parser2tree (fileCorrectName, &definitions, errorDescription);
if (result != ASN1_SUCCESS)
{
printf ("File '%s' not correct\n", fileCorrectName);
asn1_perror (result);
printf ("ErrorDescription = %s\n\n", errorDescription);
exit (1);
}
/* Only for Test */
/* asn1_visit_tree(stdout,definitions,"TEST_PARSER",ASN1_PRINT_ALL); */
/* Clear the definitions structures */
asn1_delete_structure (&definitions);
test = test_array;
while (test->lineNumber != 0)
{
testCounter++;
createFile (test->lineNumber, test->line);
result =
asn1_parser2tree (fileErroredName, &definitions, errorDescription);
asn1_delete_structure (&definitions);
if ((result != test->errorNumber) ||
(strcmp (errorDescription, test->errorDescription)))
{
errorCounter++;
printf ("ERROR N. %d:\n", errorCounter);
printf (" Line %d - %s\n", test->lineNumber, test->line);
printf (" Error expected: %s - %s\n",
asn1_strerror (test->errorNumber), test->errorDescription);
printf (" Error detected: %s - %s\n\n", asn1_strerror (result),
errorDescription);
}
test++;
}
printf ("Total tests : %d\n", testCounter);
printf ("Total errors: %d\n", errorCounter);
if (errorCounter > 0)
return 1;
exit (0);
}
