static char *
-my_ltostr(long v,char *str)
+my_ltostr (long v, char *str)
{
- long d,r;
+ long d, r;
char temp[20];
- int count,k,start;
-
- if(v<0){
- str[0]='-';
- start=1;
- v=-v;
- }
- else start=0;
-
- count=0;
- do{
- d=v/10;
- r=v-d*10;
- temp[start+count]='0'+(char)r;
- count++;
- v=d;
- }while(v);
-
- for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
- str[count+start]=0;
+ int count, k, start;
+
+ if (v < 0)
+ {
+ str[0] = '-';
+ start = 1;
+ v = -v;
+ }
+ else
+ start = 0;
+
+ count = 0;
+ do
+ {
+ d = v / 10;
+ r = v - d * 10;
+ temp[start + count] = '0' + (char) r;
+ count++;
+ v = d;
+ }
+ while (v);
+
+ for (k = 0; k < count; k++)
+ str[k + start] = temp[start + count - k - 1];
+ str[count + start] = 0;
return str;
}
/* "C=US O=gov" */
/******************************************************/
static void
-get_Name_type(ASN1_TYPE cert_def,ASN1_TYPE cert,const char *root, char *answer)
+get_Name_type (ASN1_TYPE cert_def, ASN1_TYPE cert, const char *root,
+ char *answer)
{
- int k,k2,result,len;
- char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
- ASN1_TYPE value=ASN1_TYPE_EMPTY;
+ int k, k2, result, len;
+ char name[128], str[1024], str2[1024], name2[128], counter[5], name3[128];
+ ASN1_TYPE value = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- answer[0]=0;
- k=1;
- do{
- strcpy(name,root);
- strcat(name,".rdnSequence.?");
- my_ltostr(k,counter);
- strcat(name,counter);
- len = sizeof(str) - 1;
- result=asn1_read_value(cert,name,str,&len);
- if(result==ASN1_ELEMENT_NOT_FOUND) break;
- k2=1;
- do{
- strcpy(name2,name);
- strcat(name2,".?");
- my_ltostr(k2,counter);
- strcat(name2,counter);
- len = sizeof(str) - 1;
- result=asn1_read_value(cert,name2,str,&len);
- if(result==ASN1_ELEMENT_NOT_FOUND) break;
- strcpy(name3,name2);
- strcat(name3,".type");
- len = sizeof(str) - 1;
- result=asn1_read_value(cert,name3,str,&len);
- strcpy(name3,name2);
- strcat(name3,".value");
- if(result==ASN1_SUCCESS){
- len = sizeof(str2) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
- str2,&len);
- if(!strcmp(str,str2)){
- asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
- &value);
- len = sizeof(str) - 1;
- asn1_read_value(cert,name3,str,&len);
- asn1_der_decoding(&value,str,len,errorDescription);
- len = sizeof(str) - 1;
- asn1_read_value(value,"",str,&len); /* CHOICE */
- strcpy(name3,str);
- len = sizeof(str) - 1;
- asn1_read_value(value,name3,str,&len);
- str[len]=0;
- strcat(answer," C=");
- strcat(answer,str);
- asn1_delete_structure(&value);
- }
- else{
- len = sizeof(str2) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
- ,str2,&len);
- if(!strcmp(str,str2)){
- asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName"
- ,&value);
- len = sizeof(str) - 1;
- asn1_read_value(cert,name3,str,&len);
- asn1_der_decoding(&value,str,len,errorDescription);
- len = sizeof(str) - 1;
- asn1_read_value(value,"",str,&len); /* CHOICE */
- strcpy(name3,str);
- len = sizeof(str) - 1;
- asn1_read_value(value,name3,str,&len);
- str[len]=0;
- strcat(answer," O=");
- strcat(answer,str);
- asn1_delete_structure(&value);
- }
- else{
- len = sizeof(str2) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
- if(!strcmp(str,str2)){
- asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
- len = sizeof(str) - 1;
- asn1_read_value(cert,name3,str,&len);
- asn1_der_decoding(&value,str,len,errorDescription);
- len = sizeof(str) - 1;
- asn1_read_value(value,"",str,&len); /* CHOICE */
- strcpy(name3,str);
- len = sizeof(str) - 1;
- asn1_read_value(value,name3,str,&len);
- str[len]=0;
- strcat(answer," OU=");
- strcat(answer,str);
- asn1_delete_structure(&value);
+ answer[0] = 0;
+ k = 1;
+ do
+ {
+ strcpy (name, root);
+ strcat (name, ".rdnSequence.?");
+ my_ltostr (k, counter);
+ strcat (name, counter);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert, name, str, &len);
+ if (result == ASN1_ELEMENT_NOT_FOUND)
+ break;
+ k2 = 1;
+ do
+ {
+ strcpy (name2, name);
+ strcat (name2, ".?");
+ my_ltostr (k2, counter);
+ strcat (name2, counter);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert, name2, str, &len);
+ if (result == ASN1_ELEMENT_NOT_FOUND)
+ break;
+ strcpy (name3, name2);
+ strcat (name3, ".type");
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert, name3, str, &len);
+ strcpy (name3, name2);
+ strcat (name3, ".value");
+ if (result == ASN1_SUCCESS)
+ {
+ len = sizeof (str2) - 1;
+ result =
+ asn1_read_value (cert_def,
+ "PKIX1Implicit88.id-at-countryName", str2,
+ &len);
+ if (!strcmp (str, str2))
+ {
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationName",
+ &value);
+ len = sizeof (str) - 1;
+ asn1_read_value (cert, name3, str, &len);
+ asn1_der_decoding (&value, str, len, errorDescription);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, "", str, &len); /* CHOICE */
+ strcpy (name3, str);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, name3, str, &len);
+ str[len] = 0;
+ strcat (answer, " C=");
+ strcat (answer, str);
+ asn1_delete_structure (&value);
+ }
+ else
+ {
+ len = sizeof (str2) - 1;
+ result =
+ asn1_read_value (cert_def,
+ "PKIX1Implicit88.id-at-organizationName",
+ str2, &len);
+ if (!strcmp (str, str2))
+ {
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationName",
+ &value);
+ len = sizeof (str) - 1;
+ asn1_read_value (cert, name3, str, &len);
+ asn1_der_decoding (&value, str, len, errorDescription);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, "", str, &len); /* CHOICE */
+ strcpy (name3, str);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, name3, str, &len);
+ str[len] = 0;
+ strcat (answer, " O=");
+ strcat (answer, str);
+ asn1_delete_structure (&value);
+ }
+ else
+ {
+ len = sizeof (str2) - 1;
+ result =
+ asn1_read_value (cert_def,
+ "PKIX1Implicit88.id-at-organizationalUnitName",
+ str2, &len);
+ if (!strcmp (str, str2))
+ {
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationalUnitName",
+ &value);
+ len = sizeof (str) - 1;
+ asn1_read_value (cert, name3, str, &len);
+ asn1_der_decoding (&value, str, len,
+ errorDescription);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, "", str, &len); /* CHOICE */
+ strcpy (name3, str);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, name3, str, &len);
+ str[len] = 0;
+ strcat (answer, " OU=");
+ strcat (answer, str);
+ asn1_delete_structure (&value);
+ }
+ }
+ }
}
- }
+ k2++;
}
- }
- k2++;
- }while(1);
- k++;
- }while(1);
+ while (1);
+ k++;
+ }
+ while (1);
}
/* as in rfc2459 Appendix D.1 */
/* Parameters: */
/* unsigned char *der: contains the der encoding */
-/* int *der_len: number of bytes of der string */
+/* int *der_len: number of bytes of der string */
/******************************************************/
static void
-create_certificate(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
+create_certificate (ASN1_TYPE cert_def, unsigned char *der, int *der_len)
{
- int result,k,len;
+ int result, k, len;
unsigned char str[1024];
const unsigned char *str2;
- ASN1_TYPE cert1=ASN1_TYPE_EMPTY;
- ASN1_TYPE value=ASN1_TYPE_EMPTY;
- ASN1_TYPE param=ASN1_TYPE_EMPTY;
- ASN1_TYPE constr=ASN1_TYPE_EMPTY;
+ ASN1_TYPE cert1 = ASN1_TYPE_EMPTY;
+ ASN1_TYPE value = ASN1_TYPE_EMPTY;
+ ASN1_TYPE param = ASN1_TYPE_EMPTY;
+ ASN1_TYPE constr = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
int max_len;
- max_len=*der_len;
+ max_len = *der_len;
+
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.Certificate", &cert1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.Certificate",&cert1);
-
/* Use the next 3 lines to visit the empty certificate */
/* printf("-----------------\n");
asn1_visit_tree(cert1,"");
printf("-----------------\n"); */
- /* version: v3(2) */
- result=asn1_write_value(cert1,"tbsCertificate.version","v3",0);
+ /* version: v3(2) */
+ result = asn1_write_value (cert1, "tbsCertificate.version", "v3", 0);
- /* serialNumber: 17 */
- result=asn1_write_value(cert1,"tbsCertificate.serialNumber","17",0);
+ /* serialNumber: 17 */
+ result = asn1_write_value (cert1, "tbsCertificate.serialNumber", "17", 0);
/* signature: dsa-with-sha1 */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.signature.algorithm",
- str,1);
-
- result=asn1_write_value(cert1,"tbsCertificate.signature.parameters",
- NULL,0);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.signature.algorithm", str, 1);
+ result = asn1_write_value (cert1, "tbsCertificate.signature.parameters",
+ NULL, 0);
- /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
- result=asn1_write_value(cert1,"tbsCertificate.issuer","rdnSequence",12);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+ /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer", "rdnSequence", 12);
+
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence", "NEW", 1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence.?LAST", "NEW",
+ 1);
/* C */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
- &value);
- result=asn1_write_value(value,"","US",2);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
+ &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
+ result = asn1_write_value (value, "", "US", 2);
*der_len = max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
+
+
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence", "NEW", 1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence.?LAST", "NEW",
+ 1);
/* O */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
- &value);
- result=asn1_write_value(value,"","printableString",1);
- result=asn1_write_value(value,"printableString","gov",3);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
+ &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
+ &value);
+ result = asn1_write_value (value, "", "printableString", 1);
+ result = asn1_write_value (value, "printableString", "gov", 3);
*der_len = max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence","NEW",1);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence", "NEW", 1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.issuer.rdnSequence.?LAST", "NEW",
+ 1);
/* OU */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
- str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
- result=asn1_write_value(value,"","printableString",1);
- result=asn1_write_value(value,"printableString","nist",4);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
+ str, &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationalUnitName",
+ &value);
+ result = asn1_write_value (value, "", "printableString", 1);
+ result = asn1_write_value (value, "printableString", "nist", 4);
*der_len = max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(cert1,"tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
/* validity */
- result=asn1_write_value(cert1,"tbsCertificate.validity.notBefore","utcTime",1);
- result=asn1_write_value(cert1,"tbsCertificate.validity.notBefore.utcTime","970630000000Z",1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.validity.notBefore", "utcTime",
+ 1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.validity.notBefore.utcTime",
+ "970630000000Z", 1);
- result=asn1_write_value(cert1,"tbsCertificate.validity.notAfter","utcTime",1);
- result=asn1_write_value(cert1,"tbsCertificate.validity.notAfter.utcTime","971231000000Z",1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.validity.notAfter", "utcTime",
+ 1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.validity.notAfter.utcTime",
+ "971231000000Z", 1);
/* subject: Country="US" Organization="gov" OrganizationUnit="nist" */
- result=asn1_write_value(cert1,"tbsCertificate.subject","rdnSequence",1);
-
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",1);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject", "rdnSequence", 1);
+
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence", "NEW", 1);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence.?LAST",
+ "NEW", 1);
/* C */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
- &value);
- result=asn1_write_value(value,"","US",2);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
+ &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
+ result = asn1_write_value (value, "", "US", 2);
*der_len = max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",4);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
+
+
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence", "NEW", 4);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence.?LAST",
+ "NEW", 4);
/* O */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
- &value);
- result=asn1_write_value(value,"","printableString",1);
- result=asn1_write_value(value,"printableString","gov",3);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
+ &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
+ &value);
+ result = asn1_write_value (value, "", "printableString", 1);
+ result = asn1_write_value (value, "printableString", "gov", 3);
*der_len = max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence","NEW",4);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
+
+
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence", "NEW", 4);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.subject.rdnSequence.?LAST",
+ "NEW", 4);
/* OU */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
- str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
- result=asn1_write_value(value,"","printableString",1);
- result=asn1_write_value(value,"printableString","nist",4);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
+ str, &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationalUnitName",
+ &value);
+ result = asn1_write_value (value, "", "printableString", 1);
+ result = asn1_write_value (value, "printableString", "nist", 4);
*der_len = max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(cert1,"tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
/* subjectPublicKeyInfo: dsa with parameters=Dss-Parms */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa",str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.Dss-Parms",¶m);
- str2="\xd4\x38"; /* only an example */
- result=asn1_write_value(param,"p",str2,128);
- str2="\xd4\x38"; /* only an example */
- result=asn1_write_value(param,"q",str2,20);
- str2="\xd4\x38"; /* only an example */
- result=asn1_write_value(param,"g",str2,128);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa", str, &len);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm",
+ str, 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.Dss-Parms", ¶m);
+ str2 = "\xd4\x38"; /* only an example */
+ result = asn1_write_value (param, "p", str2, 128);
+ str2 = "\xd4\x38"; /* only an example */
+ result = asn1_write_value (param, "q", str2, 20);
+ str2 = "\xd4\x38"; /* only an example */
+ result = asn1_write_value (param, "g", str2, 128);
*der_len = max_len;
- result=asn1_der_coding(param,"",der,der_len,errorDescription);
- asn1_delete_structure(¶m);
- result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.algorithm.parameters",der,*der_len);
+ result = asn1_der_coding (param, "", der, der_len, errorDescription);
+ asn1_delete_structure (¶m);
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subjectPublicKeyInfo.algorithm.parameters",
+ der, *der_len);
/* subjectPublicKey */
- str2="\x02\x81"; /* only an example */
- result=asn1_write_value(cert1,"tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",str2,1048);
+ str2 = "\x02\x81"; /* only an example */
+ result =
+ asn1_write_value (cert1,
+ "tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",
+ str2, 1048);
- result=asn1_write_value(cert1,"tbsCertificate.issuerUniqueID",NULL,0); /* NO OPTION */
- result=asn1_write_value(cert1,"tbsCertificate.subjectUniqueID",NULL,0); /* NO OPTION */
+ result = asn1_write_value (cert1, "tbsCertificate.issuerUniqueID", NULL, 0); /* NO OPTION */
+ result = asn1_write_value (cert1, "tbsCertificate.subjectUniqueID", NULL, 0); /* NO OPTION */
/* extensions */
- result=asn1_write_value(cert1,"tbsCertificate.extensions","NEW",1);
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-basicConstraints",
- str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnID",str,1); /* basicConstraints */
- result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.critical","TRUE",1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.BasicConstraints",&constr);
- result=asn1_write_value(constr,"cA","TRUE",1);
- result=asn1_write_value(constr,"pathLenConstraint",NULL,0);
- *der_len = max_len;
- result=asn1_der_coding(constr,"",der,der_len,errorDescription);
- result=asn1_delete_structure(&constr);
- result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnValue",der,*der_len);
-
-
- result=asn1_write_value(cert1,"tbsCertificate.extensions","NEW",1);
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-subjectKeyIdentifier",
- str,&len);
- result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnID",str,1); /* subjectKeyIdentifier */
- result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.critical","FALSE",1);
- str2="\x04\x14\xe7\x26\xc5"; /* only an example */
- result=asn1_write_value(cert1,"tbsCertificate.extensions.?LAST.extnValue",str2,22);
+ result = asn1_write_value (cert1, "tbsCertificate.extensions", "NEW", 1);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-basicConstraints", str,
+ &len);
+ result = asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnID", str, 1); /* basicConstraints */
+ result =
+ asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.critical",
+ "TRUE", 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.BasicConstraints",
+ &constr);
+ result = asn1_write_value (constr, "cA", "TRUE", 1);
+ result = asn1_write_value (constr, "pathLenConstraint", NULL, 0);
+ *der_len = max_len;
+ result = asn1_der_coding (constr, "", der, der_len, errorDescription);
+ result = asn1_delete_structure (&constr);
+ result =
+ asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnValue", der,
+ *der_len);
+
+
+ result = asn1_write_value (cert1, "tbsCertificate.extensions", "NEW", 1);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-subjectKeyIdentifier",
+ str, &len);
+ result = asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnID", str, 1); /* subjectKeyIdentifier */
+ result =
+ asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.critical",
+ "FALSE", 1);
+ str2 = "\x04\x14\xe7\x26\xc5"; /* only an example */
+ result =
+ asn1_write_value (cert1, "tbsCertificate.extensions.?LAST.extnValue",
+ str2, 22);
/* signatureAlgorithm: dsa-with-sha */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
- result=asn1_write_value(cert1,"signatureAlgorithm.algorithm",str,1);
- result=asn1_write_value(cert1,"signatureAlgorithm.parameters",NULL,0); /* NO OPTION */
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+ result = asn1_write_value (cert1, "signatureAlgorithm.algorithm", str, 1);
+ result = asn1_write_value (cert1, "signatureAlgorithm.parameters", NULL, 0); /* NO OPTION */
/* signature */
*der_len = max_len;
- result=asn1_der_coding(cert1,"tbsCertificate",der,der_len
- ,errorDescription);
- if(result!=ASN1_SUCCESS){
- printf("\n'tbsCertificate' encoding creation: ERROR\n");
- }
+ result =
+ asn1_der_coding (cert1, "tbsCertificate", der, der_len, errorDescription);
+ if (result != ASN1_SUCCESS)
+ {
+ printf ("\n'tbsCertificate' encoding creation: ERROR\n");
+ }
/* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
- result=asn1_write_value(cert1,"signature",str2,368); /* dsa-with-sha */
-
+ result = asn1_write_value (cert1, "signature", str2, 368); /* dsa-with-sha */
+
/* Use the next 3 lines to visit the certificate */
/* printf("-----------------\n");
printf("-----------------\n"); */
*der_len = max_len;
- result=asn1_der_coding(cert1,"",der,der_len,errorDescription);
- if(result!=ASN1_SUCCESS){
- printf("\n'certificate' encoding creation: ERROR\n");
- return;
- }
-
- /* Print the 'Certificate1' DER encoding */
- printf("-----------------\nCertificate Encoding:\nNumber of bytes=%i\n",*der_len);
- for(k=0;k<*der_len;k++) printf("%02x ",der[k]);
- printf("\n-----------------\n");
+ result = asn1_der_coding (cert1, "", der, der_len, errorDescription);
+ if (result != ASN1_SUCCESS)
+ {
+ printf ("\n'certificate' encoding creation: ERROR\n");
+ return;
+ }
+
+ /* Print the 'Certificate1' DER encoding */
+ printf ("-----------------\nCertificate Encoding:\nNumber of bytes=%i\n",
+ *der_len);
+ for (k = 0; k < *der_len; k++)
+ printf ("%02x ", der[k]);
+ printf ("\n-----------------\n");
/* Clear the "certificate1" structure */
- asn1_delete_structure(&cert1);
+ asn1_delete_structure (&cert1);
}
/* string */
/* Parameters: */
/* unsigned char *der: the encoding string */
-/* int der_len: number of bytes of der string */
+/* int der_len: number of bytes of der string */
/******************************************************/
static void
-get_certificate(ASN1_TYPE cert_def,unsigned char *der,int der_len)
+get_certificate (ASN1_TYPE cert_def, unsigned char *der, int der_len)
{
- int result,len,start,end;
- unsigned char str[1024],str2[1024];
- ASN1_TYPE cert2=ASN1_TYPE_EMPTY;
+ int result, len, start, end;
+ unsigned char str[1024], str2[1024];
+ ASN1_TYPE cert2 = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- asn1_create_element(cert_def,"PKIX1Implicit88.Certificate",&cert2);
+ asn1_create_element (cert_def, "PKIX1Implicit88.Certificate", &cert2);
- result=asn1_der_decoding(&cert2,der,der_len,errorDescription);
+ result = asn1_der_decoding (&cert2, der, der_len, errorDescription);
+
+ if (result != ASN1_SUCCESS)
+ {
+ printf ("Problems with DER encoding\n");
+ return;
+ }
- if(result!=ASN1_SUCCESS){
- printf("Problems with DER encoding\n");
- return;
- }
-
/* issuer */
- get_Name_type(cert_def,cert2,"tbsCertificate.issuer",str);
- printf("certificate:\nissuer :%s\n",str);
+ get_Name_type (cert_def, cert2, "tbsCertificate.issuer", str);
+ printf ("certificate:\nissuer :%s\n", str);
/* subject */
- get_Name_type(cert_def,cert2,"tbsCertificate.subject",str);
- printf("subject:%s\n",str);
+ get_Name_type (cert_def, cert2, "tbsCertificate.subject", str);
+ printf ("subject:%s\n", str);
/* Verify sign */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert2,"signatureAlgorithm.algorithm"
- ,str,&len);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert2, "signatureAlgorithm.algorithm", str, &len);
- len = sizeof(str2) - 1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
- if(!strcmp(str,str2)){ /* dsa-with-sha */
+ len = sizeof (str2) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str2,
+ &len);
+ if (!strcmp (str, str2))
+ { /* dsa-with-sha */
- result=asn1_der_decoding_startEnd(cert2,der,der_len,
- "tbsCertificate",&start,&end);
+ result = asn1_der_decoding_startEnd (cert2, der, der_len,
+ "tbsCertificate", &start, &end);
- /* add the lines to calculate the sha on der[start]..der[end] */
+ /* add the lines to calculate the sha on der[start]..der[end] */
- len = sizeof(str) - 1;
- result=asn1_read_value(cert2,"signature",str,&len);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert2, "signature", str, &len);
- /* compare the previous value to signature ( with issuer public key) */
- }
+ /* compare the previous value to signature ( with issuer public key) */
+ }
/* Use the next 3 lines to visit the certificate */
/* printf("-----------------\n");
/* Clear the "certificate2" structure */
- asn1_delete_structure(&cert2);
+ asn1_delete_structure (&cert2);
}
extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
/* Function : main */
/* Description: reads the certificate description. */
/* Creates a certificate and calculate */
-/* the der encoding. After that creates */
+/* the der encoding. After that creates */
/* another certificate from der string */
/********************************************************/
int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
{
- int result,der_len;
+ int result, der_len;
unsigned char der[1024];
- ASN1_TYPE PKIX1Implicit88=ASN1_TYPE_EMPTY;
+ ASN1_TYPE PKIX1Implicit88 = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- if(1)
- result=asn1_array2tree(pkix_asn1_tab,&PKIX1Implicit88,errorDescription);
+ if (1)
+ result =
+ asn1_array2tree (pkix_asn1_tab, &PKIX1Implicit88, errorDescription);
else
- result=asn1_parser2tree("pkix.asn",&PKIX1Implicit88,errorDescription);
+ result =
+ asn1_parser2tree ("pkix.asn", &PKIX1Implicit88, errorDescription);
+
+ if (result != ASN1_SUCCESS)
+ {
+ asn1_perror (result);
+ printf ("%s", errorDescription);
+ exit (1);
+ }
- 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);
+ der_len = 1024;
+ create_certificate (PKIX1Implicit88, der, &der_len);
- get_certificate(PKIX1Implicit88,der,der_len);
+ get_certificate (PKIX1Implicit88, der, der_len);
/* Clear the "PKIX1Implicit88" structures */
- asn1_delete_structure(&PKIX1Implicit88);
+ asn1_delete_structure (&PKIX1Implicit88);
return 0;
}
-
-
-
-
-
-
-
-
-
static char *
-my_ltostr(long v,char *str)
+my_ltostr (long v, char *str)
{
- long d,r;
+ long d, r;
char temp[20];
- int count,k,start;
-
- if(v<0){
- str[0]='-';
- start=1;
- v=-v;
- }
- else start=0;
-
- count=0;
- do{
- d=v/10;
- r=v-d*10;
- temp[start+count]='0'+(char)r;
- count++;
- v=d;
- }while(v);
-
- for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
- str[count+start]=0;
+ int count, k, start;
+
+ if (v < 0)
+ {
+ str[0] = '-';
+ start = 1;
+ v = -v;
+ }
+ else
+ start = 0;
+
+ count = 0;
+ do
+ {
+ d = v / 10;
+ r = v - d * 10;
+ temp[start + count] = '0' + (char) r;
+ count++;
+ v = d;
+ }
+ while (v);
+
+ for (k = 0; k < count; k++)
+ str[k + start] = temp[start + count - k - 1];
+ str[count + start] = 0;
return str;
}
/* "C=US O=gov" */
/******************************************************/
static void
-get_Name_type(ASN1_TYPE cert_def,ASN1_TYPE cert,const char *root, char *answer)
+get_Name_type (ASN1_TYPE cert_def, ASN1_TYPE cert, const char *root,
+ char *answer)
{
- int k,k2,result,len;
- char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
- ASN1_TYPE value=ASN1_TYPE_EMPTY;
+ int k, k2, result, len;
+ char name[128], str[1024], str2[1024], name2[128], counter[5], name3[128];
+ ASN1_TYPE value = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- answer[0]=0;
- k=1;
- do{
- strcpy(name,root);
- strcat(name,".rdnSequence.?");
- my_ltostr(k,counter);
- strcat(name,counter);
-
- len = sizeof(str)-1;
- result=asn1_read_value(cert,name,str,&len);
- if(result==ASN1_ELEMENT_NOT_FOUND) break;
- k2=1;
- do{
- strcpy(name2,name);
- strcat(name2,".?");
- my_ltostr(k2,counter);
- strcat(name2,counter);
-
- len = sizeof(str)-1;
- result=asn1_read_value(cert,name2,str,&len);
- if(result==ASN1_ELEMENT_NOT_FOUND) break;
- strcpy(name3,name2);
- strcat(name3,".type");
-
- len = sizeof(str)-1;
- result=asn1_read_value(cert,name3,str,&len);
- strcpy(name3,name2);
- strcat(name3,".value");
- if(result==ASN1_SUCCESS){
- len = sizeof(str2);
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
- str2,&len);
- if(!strcmp(str,str2)){
- asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
- &value);
- len = sizeof(str)-1;
- asn1_read_value(cert,name3,str,&len);
- result=asn1_der_decoding(&value,str,len,errorDescription);
-
- len = sizeof(str)-1;
- asn1_read_value(value,"",str,&len); /* CHOICE */
-
- strcpy(name3,str);
-
- len = sizeof(str)-1;
- asn1_read_value(value,name3,str,&len);
- str[len]=0;
- strcat(answer," C=");
- strcat(answer,str);
-
- asn1_delete_structure(&value);
- }
- else{
- len = sizeof(str2);
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
- ,str2,&len);
- if(!strcmp(str,str2)){
- asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName"
- ,&value);
-
- len = sizeof(str)-1;
- asn1_read_value(cert,name3,str,&len);
- asn1_der_decoding(&value,str,len,errorDescription);
- len = sizeof(str)-1;
- asn1_read_value(value,"",str,&len); /* CHOICE */
- strcpy(name3,str);
- len = sizeof(str)-1;
- asn1_read_value(value,name3,str,&len);
- str[len]=0;
- strcat(answer," O=");
- strcat(answer,str);
- asn1_delete_structure(&value);
- }
- else{
- len = sizeof(str2);
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
- if(!strcmp(str,str2)){
- asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
- len = sizeof(str)-1;
- asn1_read_value(cert,name3,str,&len);
- asn1_der_decoding(&value,str,len,errorDescription);
- len = sizeof(str)-1;
- asn1_read_value(value,"",str,&len); /* CHOICE */
- strcpy(name3,str);
- len = sizeof(str)-1;
- asn1_read_value(value,name3,str,&len);
- str[len]=0;
- strcat(answer," OU=");
- strcat(answer,str);
- asn1_delete_structure(&value);
+ answer[0] = 0;
+ k = 1;
+ do
+ {
+ strcpy (name, root);
+ strcat (name, ".rdnSequence.?");
+ my_ltostr (k, counter);
+ strcat (name, counter);
+
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert, name, str, &len);
+ if (result == ASN1_ELEMENT_NOT_FOUND)
+ break;
+ k2 = 1;
+ do
+ {
+ strcpy (name2, name);
+ strcat (name2, ".?");
+ my_ltostr (k2, counter);
+ strcat (name2, counter);
+
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert, name2, str, &len);
+ if (result == ASN1_ELEMENT_NOT_FOUND)
+ break;
+ strcpy (name3, name2);
+ strcat (name3, ".type");
+
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert, name3, str, &len);
+ strcpy (name3, name2);
+ strcat (name3, ".value");
+ if (result == ASN1_SUCCESS)
+ {
+ len = sizeof (str2);
+ result =
+ asn1_read_value (cert_def,
+ "PKIX1Implicit88.id-at-countryName", str2,
+ &len);
+ if (!strcmp (str, str2))
+ {
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationName",
+ &value);
+ len = sizeof (str) - 1;
+ asn1_read_value (cert, name3, str, &len);
+ result =
+ asn1_der_decoding (&value, str, len, errorDescription);
+
+ len = sizeof (str) - 1;
+ asn1_read_value (value, "", str, &len); /* CHOICE */
+
+ strcpy (name3, str);
+
+ len = sizeof (str) - 1;
+ asn1_read_value (value, name3, str, &len);
+ str[len] = 0;
+ strcat (answer, " C=");
+ strcat (answer, str);
+
+ asn1_delete_structure (&value);
+ }
+ else
+ {
+ len = sizeof (str2);
+ result =
+ asn1_read_value (cert_def,
+ "PKIX1Implicit88.id-at-organizationName",
+ str2, &len);
+ if (!strcmp (str, str2))
+ {
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationName",
+ &value);
+
+ len = sizeof (str) - 1;
+ asn1_read_value (cert, name3, str, &len);
+ asn1_der_decoding (&value, str, len, errorDescription);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, "", str, &len); /* CHOICE */
+ strcpy (name3, str);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, name3, str, &len);
+ str[len] = 0;
+ strcat (answer, " O=");
+ strcat (answer, str);
+ asn1_delete_structure (&value);
+ }
+ else
+ {
+ len = sizeof (str2);
+ result =
+ asn1_read_value (cert_def,
+ "PKIX1Implicit88.id-at-organizationalUnitName",
+ str2, &len);
+ if (!strcmp (str, str2))
+ {
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationalUnitName",
+ &value);
+ len = sizeof (str) - 1;
+ asn1_read_value (cert, name3, str, &len);
+ asn1_der_decoding (&value, str, len,
+ errorDescription);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, "", str, &len); /* CHOICE */
+ strcpy (name3, str);
+ len = sizeof (str) - 1;
+ asn1_read_value (value, name3, str, &len);
+ str[len] = 0;
+ strcat (answer, " OU=");
+ strcat (answer, str);
+ asn1_delete_structure (&value);
+ }
+ }
+ }
}
- }
+ k2++;
}
- }
- k2++;
- }while(1);
- k++;
- }while(1);
+ while (1);
+ k++;
+ }
+ while (1);
}
/* as in rfc2459 Appendix D.1 */
/* Parameters: */
/* unsigned char *der: contains the der encoding */
-/* int *der_len: number of bytes of der string */
+/* int *der_len: number of bytes of der string */
/******************************************************/
static void
-create_CRL(ASN1_TYPE cert_def, unsigned char *der,int *der_len)
+create_CRL (ASN1_TYPE cert_def, unsigned char *der, int *der_len)
{
- int result,k,len;
+ int result, k, len;
unsigned char str[1024];
const unsigned char *str2;
- ASN1_TYPE crl=ASN1_TYPE_EMPTY;
- ASN1_TYPE value=ASN1_TYPE_EMPTY;
+ ASN1_TYPE crl = ASN1_TYPE_EMPTY;
+ ASN1_TYPE value = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
int max_len;
- max_len=*der_len;
+ max_len = *der_len;
+
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.CertificateList", &crl);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.CertificateList",&crl);
-
- /* Use the next 3 lines to visit the empty certificate */
+ /* Use the next 3 lines to visit the empty certificate */
/* printf("-----------------\n");
- asn1_visit_tree(crl,"");
- printf("-----------------\n"); */
-
+ asn1_visit_tree(crl,"");
+ printf("-----------------\n"); */
+
- /* version: v2(1) */
- result=asn1_write_value(crl,"tbsCertList.version","v2",0);
+ /* version: v2(1) */
+ result = asn1_write_value (crl, "tbsCertList.version", "v2", 0);
/* signature: dsa-with-sha */
- len = sizeof(str)-1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
- result=asn1_write_value(crl,"tbsCertList.signature.algorithm",str,1);
- result=asn1_write_value(crl,"tbsCertList.signature.parameters",NULL,0);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+ result = asn1_write_value (crl, "tbsCertList.signature.algorithm", str, 1);
+ result =
+ asn1_write_value (crl, "tbsCertList.signature.parameters", NULL, 0);
/* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
- result=asn1_write_value(crl,"tbsCertList.issuer","rdnSequence",1);
+ result = asn1_write_value (crl, "tbsCertList.issuer", "rdnSequence", 1);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",1);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
+ result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 1);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 1);
/* C */
- len = sizeof(str)-1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520countryName",
- &value);
- result=asn1_write_value(value,"","US",2);
- *der_len=max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
-
- asn1_delete_structure(&value);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",4);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",4);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
+ &len);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
+ result = asn1_write_value (value, "", "US", 2);
+ *der_len = max_len;
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
+
+
+ result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 4);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 4);
/* O */
- len = sizeof(str)-1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,8);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationName",
- &value);
- result=asn1_write_value(value,"","printableString",1);
- result=asn1_write_value(value,"printableString","gov",3);
- *der_len=max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
-
-
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence","NEW",1);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
+ &len);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
+ str, 8);
+ result =
+ asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
+ &value);
+ result = asn1_write_value (value, "", "printableString", 1);
+ result = asn1_write_value (value, "printableString", "gov", 3);
+ *der_len = max_len;
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
+
+
+ result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 1);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 1);
/* OU */
- len = sizeof(str)-1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
- str,&len);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
- result=asn1_create_element(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value);
- result=asn1_write_value(value,"","printableString",1);
- result=asn1_write_value(value,"printableString","nist",4);
- *der_len=max_len;
- result=asn1_der_coding(value,"",der,der_len,errorDescription);
- asn1_delete_structure(&value);
- result=asn1_write_value(crl,"tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
+ str, &len);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
+ str, 1);
+ result =
+ asn1_create_element (cert_def,
+ "PKIX1Implicit88.X520OrganizationalUnitName",
+ &value);
+ result = asn1_write_value (value, "", "printableString", 1);
+ result = asn1_write_value (value, "printableString", "nist", 4);
+ *der_len = max_len;
+ result = asn1_der_coding (value, "", der, der_len, errorDescription);
+ asn1_delete_structure (&value);
+ result =
+ asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
+ der, *der_len);
/* validity */
- result=asn1_write_value(crl,"tbsCertList.thisUpdate","utcTime",1);
- result=asn1_write_value(crl,"tbsCertList.thisUpdate.utcTime","970801000000Z",1);
+ result = asn1_write_value (crl, "tbsCertList.thisUpdate", "utcTime", 1);
+ result =
+ asn1_write_value (crl, "tbsCertList.thisUpdate.utcTime", "970801000000Z",
+ 1);
- result=asn1_write_value(crl,"tbsCertList.nextUpdate","utcTime",1);
- result=asn1_write_value(crl,"tbsCertList.nextUpdate.utcTime","970808000000Z",1);
+ result = asn1_write_value (crl, "tbsCertList.nextUpdate", "utcTime", 1);
+ result =
+ asn1_write_value (crl, "tbsCertList.nextUpdate.utcTime", "970808000000Z",
+ 1);
/* revokedCertificates */
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates","NEW",1);
- str[0]=18;
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.userCertificate",str,1);
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.revocationDate","utcTime",1);
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime","970731000000Z",1);
-
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions","NEW",1);
- len = sizeof(str)-1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-cRLReasons",
- str,&len);
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID",str,1); /* reasonCode */
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical","FALSE",1);
- str2="\x0a\x01\x01";
- result=asn1_write_value(crl,"tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",str2,3);
+ result =
+ asn1_write_value (crl, "tbsCertList.revokedCertificates", "NEW", 1);
+ str[0] = 18;
+ result =
+ asn1_write_value (crl,
+ "tbsCertList.revokedCertificates.?LAST.userCertificate",
+ str, 1);
+ result =
+ asn1_write_value (crl,
+ "tbsCertList.revokedCertificates.?LAST.revocationDate",
+ "utcTime", 1);
+ result =
+ asn1_write_value (crl,
+ "tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime",
+ "970731000000Z", 1);
+
+ result =
+ asn1_write_value (crl,
+ "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions",
+ "NEW", 1);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-cRLReasons",
+ str, &len);
+ result = asn1_write_value (crl, "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID", str, 1); /* reasonCode */
+ result =
+ asn1_write_value (crl,
+ "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical",
+ "FALSE", 1);
+ str2 = "\x0a\x01\x01";
+ result =
+ asn1_write_value (crl,
+ "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",
+ str2, 3);
/* crlExtensions */
- result=asn1_write_value(crl,"tbsCertList.crlExtensions",NULL,0);
+ result = asn1_write_value (crl, "tbsCertList.crlExtensions", NULL, 0);
/* signatureAlgorithm: dsa-with-sha */
- len = sizeof(str)-1;
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
- result=asn1_write_value(crl,"signatureAlgorithm.algorithm",str,1);
- result=asn1_write_value(crl,"signatureAlgorithm.parameters",NULL,0); /* NO OPTION */
+ len = sizeof (str) - 1;
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
+ result = asn1_write_value (crl, "signatureAlgorithm.algorithm", str, 1);
+ result = asn1_write_value (crl, "signatureAlgorithm.parameters", NULL, 0); /* NO OPTION */
/* signature */
- *der_len=max_len;
- result=asn1_der_coding(crl,"tbsCertList",der,der_len,errorDescription);
- if(result!=ASN1_SUCCESS){
- printf("\n'tbsCertList' encoding creation: ERROR\n");
- return;
- }
+ *der_len = max_len;
+ result =
+ asn1_der_coding (crl, "tbsCertList", der, der_len, errorDescription);
+ if (result != ASN1_SUCCESS)
+ {
+ printf ("\n'tbsCertList' encoding creation: ERROR\n");
+ return;
+ }
/* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
- result=asn1_write_value(crl,"signature",str2,46*8);
-
+ result = asn1_write_value (crl, "signature", str2, 46 * 8);
+
/* Use the next 3 lines to visit the certificate */
/* printf("-----------------\n");
asn1_visit_tree(crl,"");
printf("-----------------\n"); */
- *der_len=max_len;
- result=asn1_der_coding(crl,"",der,der_len,errorDescription);
- if(result!=ASN1_SUCCESS){
- printf("\n'crl1' encoding creation: ERROR\n");
- return;
- }
-
- /* Print the 'Certificate1' DER encoding */
- printf("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",*der_len);
- for(k=0;k<*der_len;k++) printf("%02x ",der[k]);
- printf("\n-----------------\n");
+ *der_len = max_len;
+ result = asn1_der_coding (crl, "", der, der_len, errorDescription);
+ if (result != ASN1_SUCCESS)
+ {
+ printf ("\n'crl1' encoding creation: ERROR\n");
+ return;
+ }
+
+ /* Print the 'Certificate1' DER encoding */
+ printf ("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",
+ *der_len);
+ for (k = 0; k < *der_len; k++)
+ printf ("%02x ", der[k]);
+ printf ("\n-----------------\n");
/* Clear the "certificate1" structure */
- asn1_delete_structure(&crl);
+ asn1_delete_structure (&crl);
}
/* string */
/* Parameters: */
/* unsigned char *der: the encoding string */
-/* int der_len: number of bytes of der string */
+/* int der_len: number of bytes of der string */
/******************************************************/
static void
-get_CRL(ASN1_TYPE cert_def,unsigned char *der,int der_len)
+get_CRL (ASN1_TYPE cert_def, unsigned char *der, int der_len)
{
- int result,len,start,end;
- unsigned char str[1024],str2[1024];
- ASN1_TYPE crl2=ASN1_TYPE_EMPTY;
+ int result, len, start, end;
+ unsigned char str[1024], str2[1024];
+ ASN1_TYPE crl2 = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- asn1_create_element(cert_def,"PKIX1Implicit88.CertificateList",&crl2);
+ asn1_create_element (cert_def, "PKIX1Implicit88.CertificateList", &crl2);
+
+ result = asn1_der_decoding (&crl2, der, der_len, errorDescription);
+
+ if (result != ASN1_SUCCESS)
+ {
+ printf ("Problems with DER encoding\n");
+ return;
+ }
- result=asn1_der_decoding(&crl2,der,der_len,errorDescription);
-
- if(result!=ASN1_SUCCESS){
- printf("Problems with DER encoding\n");
- return;
- }
-
/* issuer */
- get_Name_type(cert_def,crl2,"tbsCertList.issuer",str);
- printf("crl2:\nissuer: %s\n",str);
+ get_Name_type (cert_def, crl2, "tbsCertList.issuer", str);
+ printf ("crl2:\nissuer: %s\n", str);
/* Verify sign */
- len = sizeof(str)-1;
- result=asn1_read_value(crl2,"signatureAlgorithm.algorithm",str,&len);
+ len = sizeof (str) - 1;
+ result = asn1_read_value (crl2, "signatureAlgorithm.algorithm", str, &len);
- result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
- if(!strcmp(str,str2)){ /* dsa-with-sha */
+ result =
+ asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str2,
+ &len);
+ if (!strcmp (str, str2))
+ { /* dsa-with-sha */
- result=asn1_der_decoding_startEnd(crl2,der,der_len,
- "tbsCertList",&start,&end);
+ result = asn1_der_decoding_startEnd (crl2, der, der_len,
+ "tbsCertList", &start, &end);
- /* add the lines to calculate the sha on der[start]..der[end] */
+ /* add the lines to calculate the sha on der[start]..der[end] */
- result=asn1_read_value(crl2,"signature",str,&len);
+ result = asn1_read_value (crl2, "signature", str, &len);
- /* compare the previous value to signature ( with issuer public key) */
- }
+ /* compare the previous value to signature ( with issuer public key) */
+ }
/* Use the next 3 lines to visit the certificate */
/* printf("-----------------\n");
/* Clear the "crl2" structure */
- asn1_delete_structure(&crl2);
+ asn1_delete_structure (&crl2);
}
extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
/* Function : main */
/* Description: reads the certificate description. */
/* Creates a certificate and calculate */
-/* the der encoding. After that creates */
+/* the der encoding. After that creates */
/* another certificate from der string */
/********************************************************/
int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
{
- int result,der_len;
+ int result, der_len;
unsigned char der[1024];
- ASN1_TYPE PKIX1Implicit88=ASN1_TYPE_EMPTY;
+ ASN1_TYPE PKIX1Implicit88 = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- if(1)
- result=asn1_array2tree(pkix_asn1_tab,&PKIX1Implicit88,errorDescription);
+ 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\n",errorDescription);
- exit(1);
- }
-
+ result =
+ asn1_parser2tree ("pkix.asn", &PKIX1Implicit88, errorDescription);
+
+ if (result != ASN1_SUCCESS)
+ {
+ asn1_perror (result);
+ printf ("%s\n", errorDescription);
+ exit (1);
+ }
+
/* Use the following 3 lines to visit the PKIX1Implicit structures */
/* printf("-----------------\n");
asn1_visit_tree(cert_def,"PKIX1Implicit88");
printf("-----------------\n"); */
- der_len=1024;
- create_CRL(PKIX1Implicit88,der,&der_len);
+ der_len = 1024;
+ create_CRL (PKIX1Implicit88, der, &der_len);
- get_CRL(PKIX1Implicit88,der,der_len);
+ get_CRL (PKIX1Implicit88, der, der_len);
/* Clear the "PKIX1Implicit88" structures */
- asn1_delete_structure(&PKIX1Implicit88);
+ asn1_delete_structure (&PKIX1Implicit88);
return 0;
}
-
-
-
-
-
-
-
-
-
/* Return: */
/******************************************************/
static void
-_asn1_error_description_value_not_found (ASN1_TYPE node,
+_asn1_error_description_value_not_found (ASN1_TYPE node,
char *ErrorDescription)
{
/* otherwise ASN1_SUCCESS. */
/******************************************************/
static asn1_retCode
-_asn1_complete_explicit_tag (ASN1_TYPE node, unsigned char *der,
+_asn1_complete_explicit_tag (ASN1_TYPE node, unsigned char *der,
int *counter, int *max_len)
{
ASN1_TYPE p;
/* otherwise ASN1_SUCCESS. */
/******************************************************/
static asn1_retCode
-_asn1_insert_tag_der (ASN1_TYPE node, unsigned char *der, int *counter,
+_asn1_insert_tag_der (ASN1_TYPE node, unsigned char *der, int *counter,
int *max_len)
{
ASN1_TYPE p;
/* Return: */
/******************************************************/
static void
-_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE node)
+_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE node)
{
struct vet
{
/* Return: */
/******************************************************/
static void
-_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE node)
+_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE node)
{
struct vet
{
int ret;
long err;
- ret = asn1_get_length_der( ber, ber_len, len);
+ ret = asn1_get_length_der (ber, ber_len, len);
if (ret == -1)
- { /* indefinite length method */
+ { /* indefinite length method */
ret = ber_len;
- err = _asn1_get_indefinite_length_string (ber+1, &ret);
+ err = _asn1_get_indefinite_length_string (ber + 1, &ret);
if (err != ASN1_SUCCESS)
return -3;
}
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
-
+
counter += len2;
if (counter > der_len)
return ASN1_DER_ERROR;
}
static asn1_retCode
-_asn1_extract_der_octet(ASN1_TYPE node, const unsigned char *der, int der_len)
+_asn1_extract_der_octet (ASN1_TYPE node, const unsigned char *der,
+ int der_len)
{
-int len2, len3;
-int counter2, counter_end;
+ int len2, len3;
+ int counter2, counter_end;
- len2 = asn1_get_length_der (der, der_len, &len3);
- if (len2 < -1)
- return ASN1_DER_ERROR;
+ len2 = asn1_get_length_der (der, der_len, &len3);
+ if (len2 < -1)
+ return ASN1_DER_ERROR;
- counter2 = len3 + 1;
+ counter2 = len3 + 1;
- if (len2 == -1)
- counter_end = der_len - 2;
- else
- counter_end = der_len;
+ if (len2 == -1)
+ counter_end = der_len - 2;
+ else
+ counter_end = der_len;
- while (counter2 < counter_end)
- {
- len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
+ while (counter2 < counter_end)
+ {
+ len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
- if (len2 < -1)
- return ASN1_DER_ERROR;
+ if (len2 < -1)
+ return ASN1_DER_ERROR;
- if (len2 > 0)
- {
- _asn1_append_value( node, der + counter2 + len3, len2);
- }
- else
- { /* indefinite */
-
- len2 = _asn1_extract_der_octet( node, der+counter2+len3, der_len-counter2-len3);
- if (len2 < 0)
- return len2;
- }
-
- counter2 += len2 + len3 + 1;
- }
-
- return ASN1_SUCCESS;
+ if (len2 > 0)
+ {
+ _asn1_append_value (node, der + counter2 + len3, len2);
+ }
+ else
+ { /* indefinite */
+
+ len2 =
+ _asn1_extract_der_octet (node, der + counter2 + len3,
+ der_len - counter2 - len3);
+ if (len2 < 0)
+ return len2;
+ }
+
+ counter2 += len2 + len3 + 1;
+ }
+
+ return ASN1_SUCCESS;
}
{
unsigned char temp[DER_LEN];
int ret;
-
- len2 = sizeof(temp);
+
+ len2 = sizeof (temp);
asn1_length_der (tot_len, temp, &len2);
_asn1_set_value (node, temp, len2);
tot_len += len2;
- ret = _asn1_extract_der_octet(node, der, *len);
- if (ret!=ASN1_SUCCESS)
- return ret;
+ ret = _asn1_extract_der_octet (node, der, *len);
+ if (ret != ASN1_SUCCESS)
+ return ret;
}
}
if (len4 != -1)
{
len2 += len4;
- _asn1_set_value_octet (p, der+counter, len2+len3);
+ _asn1_set_value_octet (p, der + counter, len2 + len3);
counter += len2 + len3;
}
else
return ris;
}
- _asn1_set_value_octet (p, der+counter, len2);
+ _asn1_set_value_octet (p, der + counter, len2);
counter += len2;
/* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
len2 += len4;
if (state == FOUND)
{
- _asn1_set_value_octet (p, der+counter, len2+len3);
+ _asn1_set_value_octet (p, der + counter, len2 + len3);
temp2 = NULL;
if (p == nodeFound)
if (state == FOUND)
{
- _asn1_set_value_octet (p, der+counter, len2);
+ _asn1_set_value_octet (p, der + counter, len2);
if (p == nodeFound)
state = EXIT;
#include "element.h"
void
-_asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
+_asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
{
ASN1_TYPE p;
char tmp_name[64];
int
-_asn1_append_sequence_set (ASN1_TYPE node)
+_asn1_append_sequence_set (ASN1_TYPE node)
{
ASN1_TYPE p, p2;
char temp[10];
(!negative && (value_temp[k] & 0x80)))
k--;
- _asn1_set_value_octet (node, value_temp+k, len-k);
+ _asn1_set_value_octet (node, value_temp + k, len - k);
if (node->type & CONST_DEFAULT)
{
#define _ELEMENT_H
-asn1_retCode _asn1_append_sequence_set(ASN1_TYPE node);
+asn1_retCode _asn1_append_sequence_set (ASN1_TYPE node);
-asn1_retCode _asn1_convert_integer(const char *value,unsigned char *value_out,
- int value_out_size, int *len);
+asn1_retCode _asn1_convert_integer (const char *value,
+ unsigned char *value_out,
+ int value_out_size, int *len);
-void _asn1_hierarchical_name(ASN1_TYPE node,char *name,int name_size);
+void _asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size);
#endif
-void _asn1_str_cpy( char* dest, size_t dest_tot_size, const char* src);
-void _asn1_str_cat( char* dest, size_t dest_tot_size, const char* src);
+void _asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
+void _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
#define Estrcpy(x,y) _asn1_str_cpy(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
#define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
#define _asn1_realloc realloc
#define _asn1_strdup strdup
-#define MAX_LOG_SIZE 1024 /* maximum number of characters of a log message */
+#define MAX_LOG_SIZE 1024 /* maximum number of characters of a log message */
/* Define used for visiting trees. */
#define UP 1
#define CONST_EXPLICIT (1<<11)
#define CONST_IMPLICIT (1<<12)
-#define CONST_TAG (1<<13) /* Used in ASN.1 assignement */
+#define CONST_TAG (1<<13) /* Used in ASN.1 assignement */
#define CONST_OPTION (1<<14)
#define CONST_DEFAULT (1<<15)
#define CONST_TRUE (1<<16)
#define CONST_FALSE (1<<17)
-#define CONST_LIST (1<<18) /* Used with TYPE_INTEGER and TYPE_BIT_STRING */
+#define CONST_LIST (1<<18) /* Used with TYPE_INTEGER and TYPE_BIT_STRING */
#define CONST_MIN_MAX (1<<19)
#define CONST_1_PARAM (1<<20)
#include <time.h>
#ifdef __cplusplus
-extern "C" {
+extern "C"
+{
#endif
#define ASN1_VERSION "2.0"
/*****************************************/
struct static_struct_asn
{
- const char *name; /* Node name */
- unsigned int type; /* Node type */
- const void *value; /* Node value */
+ const char *name; /* Node name */
+ unsigned int type; /* Node type */
+ const void *value; /* Node value */
};
typedef struct static_struct_asn ASN1_ARRAY_TYPE;
ASN1_TYPE * definitions,
char *errorDescription);
- void asn1_print_structure (FILE *out, ASN1_TYPE structure, const char *name,
- int mode);
+ void asn1_print_structure (FILE * out, ASN1_TYPE structure,
+ const char *name, int mode);
asn1_retCode asn1_create_element (ASN1_TYPE definitions,
const char *source_name,
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
ASN1_TYPE
-_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len)
+_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len)
{
if (node == NULL)
return node;
if (node->value)
{
- if (node->value != node->small_value) _asn1_free (node->value);
+ if (node->value != node->small_value)
+ _asn1_free (node->value);
node->value = NULL;
node->value_len = 0;
}
if (!len)
return node;
- if (len < sizeof(node->small_value)) {
- node->value = node->small_value;
- } else {
- node->value = _asn1_malloc (len);
- if (node->value == NULL)
- return NULL;
- }
+ if (len < sizeof (node->small_value))
+ {
+ node->value = node->small_value;
+ }
+ else
+ {
+ node->value = _asn1_malloc (len);
+ if (node->value == NULL)
+ return NULL;
+ }
node->value_len = len;
memcpy (node->value, value, len);
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
ASN1_TYPE
-_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len)
+_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len)
{
-int len2;
-void* temp;
+ int len2;
+ void *temp;
if (node == NULL)
return node;
* value.
*/
ASN1_TYPE
-_asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len)
+_asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len)
{
if (node == NULL)
return node;
if (node->value)
{
- if (node->value != node->small_value) _asn1_free (node->value);
+ if (node->value != node->small_value)
+ _asn1_free (node->value);
node->value = NULL;
node->value_len = 0;
}
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
ASN1_TYPE
-_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len)
+_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len)
{
if (node == NULL)
return node;
{
/* value is allocated */
int prev_len = node->value_len;
- node->value_len+=len;
- node->value = _asn1_realloc( node->value, node->value_len);
- if (node->value == NULL) {
- node->value_len = 0;
- return NULL;
- }
- memcpy( &node->value[prev_len], value, len);
+ node->value_len += len;
+ node->value = _asn1_realloc (node->value, node->value_len);
+ if (node->value == NULL)
+ {
+ node->value_len = 0;
+ return NULL;
+ }
+ memcpy (&node->value[prev_len], value, len);
return node;
}
{
/* value is in node */
int prev_len = node->value_len;
- node->value_len+=len;
- node->value = _asn1_malloc( node->value_len);
- if (node->value == NULL) {
- node->value_len = 0;
- return NULL;
- }
- memcpy( node->value, node->small_value, prev_len);
- memcpy( &node->value[prev_len], value, len);
+ node->value_len += len;
+ node->value = _asn1_malloc (node->value_len);
+ if (node->value == NULL)
+ {
+ node->value_len = 0;
+ return NULL;
+ }
+ memcpy (node->value, node->small_value, prev_len);
+ memcpy (&node->value[prev_len], value, len);
return node;
}
- else /* node->value == NULL */
- return _asn1_set_value(node, value, len);
+ else /* node->value == NULL */
+ return _asn1_set_value (node, value, len);
}
/******************************************************************/
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
ASN1_TYPE
-_asn1_set_name (ASN1_TYPE node, const char *name)
+_asn1_set_name (ASN1_TYPE node, const char *name)
{
if (node == NULL)
return node;
/* Return: pointer to *NODE. */
/******************************************************************/
ASN1_TYPE
-_asn1_set_right (ASN1_TYPE node, ASN1_TYPE right)
+_asn1_set_right (ASN1_TYPE node, ASN1_TYPE right)
{
if (node == NULL)
return node;
/* Return: field RIGHT of NODE. */
/******************************************************************/
ASN1_TYPE
-_asn1_get_right (ASN1_TYPE node)
+_asn1_get_right (ASN1_TYPE node)
{
if (node == NULL)
return NULL;
/* Return: pointer to the last element along the right chain. */
/******************************************************************/
ASN1_TYPE
-_asn1_get_last_right (ASN1_TYPE node)
+_asn1_get_last_right (ASN1_TYPE node)
{
ASN1_TYPE p;
/* Return: pointer to *NODE. */
/******************************************************************/
ASN1_TYPE
-_asn1_set_down (ASN1_TYPE node, ASN1_TYPE down)
+_asn1_set_down (ASN1_TYPE node, ASN1_TYPE down)
{
if (node == NULL)
return node;
/* Return: field DOWN of NODE. */
/******************************************************************/
ASN1_TYPE
-_asn1_get_down (ASN1_TYPE node)
+_asn1_get_down (ASN1_TYPE node)
{
if (node == NULL)
return NULL;
/* Return: a null terminated string. */
/******************************************************************/
char *
-_asn1_get_name (ASN1_TYPE node)
+_asn1_get_name (ASN1_TYPE node)
{
if (node == NULL)
return NULL;
/* Return: NODE pointer. */
/******************************************************************/
ASN1_TYPE
-_asn1_mod_type (ASN1_TYPE node, unsigned int value)
+_asn1_mod_type (ASN1_TYPE node, unsigned int value)
{
if (node == NULL)
return node;
/* node: NODE_ASN element pointer. */
/******************************************************************/
void
-_asn1_remove_node (ASN1_TYPE node)
+_asn1_remove_node (ASN1_TYPE node)
{
if (node == NULL)
return;
/* Return: Null if not found. */
/******************************************************************/
ASN1_TYPE
-_asn1_find_up (ASN1_TYPE node)
+_asn1_find_up (ASN1_TYPE node)
{
ASN1_TYPE p;
/***************************************/
/* Functions used by ASN.1 parser */
/***************************************/
-ASN1_TYPE
-_asn1_add_node(unsigned int type);
+ASN1_TYPE _asn1_add_node (unsigned int type);
ASN1_TYPE
-_asn1_set_value(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len);
-ASN1_TYPE
-_asn1_set_value_m(ASN1_TYPE node,void *value,unsigned int len);
+ASN1_TYPE _asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len);
ASN1_TYPE
-_asn1_set_value_octet(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len);
ASN1_TYPE
-_asn1_append_value(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len);
-ASN1_TYPE
-_asn1_set_name(ASN1_TYPE node,const char *name);
+ASN1_TYPE _asn1_set_name (ASN1_TYPE node, const char *name);
-ASN1_TYPE
-_asn1_set_right(ASN1_TYPE node, ASN1_TYPE right);
+ASN1_TYPE _asn1_set_right (ASN1_TYPE node, ASN1_TYPE right);
-ASN1_TYPE
-_asn1_get_right(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_right (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_get_last_right(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_last_right (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_set_down(ASN1_TYPE node, ASN1_TYPE down);
+ASN1_TYPE _asn1_set_down (ASN1_TYPE node, ASN1_TYPE down);
-char *
-_asn1_get_name(ASN1_TYPE node);
+char *_asn1_get_name (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_get_down(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_down (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_mod_type(ASN1_TYPE node,unsigned int value);
+ASN1_TYPE _asn1_mod_type (ASN1_TYPE node, unsigned int value);
-void
-_asn1_remove_node(ASN1_TYPE node);
+void _asn1_remove_node (ASN1_TYPE node);
-void _asn1_delete_list(void);
+void _asn1_delete_list (void);
-void _asn1_delete_list_and_nodes(void);
+void _asn1_delete_list_and_nodes (void);
-char * _asn1_ltostr(long v,char *str);
+char *_asn1_ltostr (long v, char *str);
-ASN1_TYPE _asn1_find_up(ASN1_TYPE node);
+ASN1_TYPE _asn1_find_up (ASN1_TYPE node);
-asn1_retCode _asn1_change_integer_value(ASN1_TYPE node);
+asn1_retCode _asn1_change_integer_value (ASN1_TYPE node);
-asn1_retCode _asn1_expand_object_id(ASN1_TYPE node);
+asn1_retCode _asn1_expand_object_id (ASN1_TYPE node);
-asn1_retCode _asn1_type_set_config(ASN1_TYPE node);
+asn1_retCode _asn1_type_set_config (ASN1_TYPE node);
-asn1_retCode _asn1_check_identifier(ASN1_TYPE node);
+asn1_retCode _asn1_check_identifier (ASN1_TYPE node);
-asn1_retCode _asn1_set_default_tag(ASN1_TYPE node);
+asn1_retCode _asn1_set_default_tag (ASN1_TYPE node);
#endif
-
-
-
/* Return: NULL if not found. */
/******************************************************************/
ASN1_TYPE
-_asn1_find_left (ASN1_TYPE node)
+_asn1_find_left (ASN1_TYPE node)
{
if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
return NULL;
}
ASN1_TYPE
-_asn1_copy_structure3 (ASN1_TYPE source_node)
+_asn1_copy_structure3 (ASN1_TYPE source_node)
{
ASN1_TYPE dest_node, p_s, p_d, p_d_prev;
int move;
if (p_s->name)
_asn1_set_name (p_d, p_s->name);
if (p_s->value)
- _asn1_set_value (p_d, p_s->value, p_s->value_len);
+ _asn1_set_value (p_d, p_s->value, p_s->value_len);
move = DOWN;
}
else
static ASN1_TYPE
-_asn1_copy_structure2 (ASN1_TYPE root, const char *source_name)
+_asn1_copy_structure2 (ASN1_TYPE root, const char *source_name)
{
ASN1_TYPE source_node;
static asn1_retCode
-_asn1_type_choice_config (ASN1_TYPE node)
+_asn1_type_choice_config (ASN1_TYPE node)
{
ASN1_TYPE p, p2, p3, p4;
int move, tlen;
static asn1_retCode
-_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE root)
+_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE root)
{
ASN1_TYPE p, p2, p3;
char name2[ASN1_MAX_NAME_SIZE + 2];
#ifndef _STRUCTURE_H
#define _STRUCTURE_H
-asn1_retCode _asn1_create_static_structure(ASN1_TYPE pointer,
- char* output_file_name,char *vector_name);
+asn1_retCode _asn1_create_static_structure (ASN1_TYPE pointer,
+ char *output_file_name,
+ char *vector_name);
-ASN1_TYPE _asn1_copy_structure3(ASN1_TYPE source_node);
+ASN1_TYPE _asn1_copy_structure3 (ASN1_TYPE source_node);
-ASN1_TYPE _asn1_add_node_only(unsigned int type);
+ASN1_TYPE _asn1_add_node_only (unsigned int type);
-ASN1_TYPE _asn1_find_left(ASN1_TYPE node);
+ASN1_TYPE _asn1_find_left (ASN1_TYPE node);
#endif
-
/*****************************************************/
/* File: asn1Coding.c */
/* Description: program to generate a DER coding */
-/* of an ASN1 definition. */
+/* of an ASN1 definition. */
/*****************************************************/
#include <config.h>
" -o, --output FILE output file\n"
" -h, --help display this help and exit\n"
" -v, --version output version information and exit.\n"
- "\n"
- "Report bugs to <" PACKAGE_BUGREPORT ">.";
+ "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.";
#define ASSIGNMENT_SUCCESS 1
#define ASSIGNMENT_ERROR 2
#define ASSIGNMENT_EOF 3
static int
-readAssignment(FILE *file,char *varName, char *value){
+readAssignment (FILE * file, char *varName, char *value)
+{
int ret;
- ret=fscanf(file,"%s",varName);
- if(ret==EOF) return ASSIGNMENT_EOF;
- if(!strcmp(varName,"''")) varName[0]=0;
+ ret = fscanf (file, "%s", varName);
+ if (ret == EOF)
+ return ASSIGNMENT_EOF;
+ if (!strcmp (varName, "''"))
+ varName[0] = 0;
- ret=fscanf(file,"%s",value);
- if(ret==EOF) return ASSIGNMENT_ERROR;
+ ret = fscanf (file, "%s", value);
+ if (ret == EOF)
+ return ASSIGNMENT_ERROR;
return ASSIGNMENT_SUCCESS;
}
static void
-createFileName(char *inputFileName, char **outputFileName)
+createFileName (char *inputFileName, char **outputFileName)
{
- char *char_p,*slash_p,*dot_p;
-
- /* searching the last '/' and '.' in inputFileAssignmentName */
- char_p=inputFileName;
- slash_p=inputFileName;
- while((char_p=strchr(char_p,'/'))){
- char_p++;
- slash_p=char_p;
- }
-
- char_p=slash_p;
- dot_p=inputFileName+strlen(inputFileName);
-
- while((char_p=strchr(char_p,'.'))){
- dot_p=char_p;
- char_p++;
- }
-
- /* outputFileName= inputFileName + .out */
- *outputFileName=(char *)malloc(dot_p-inputFileName+1+
- strlen(".out"));
- memcpy(*outputFileName,inputFileName,
- dot_p-inputFileName);
- (*outputFileName)[dot_p-inputFileName]=0;
- strcat(*outputFileName,".out");
- return;
+ char *char_p, *slash_p, *dot_p;
+
+ /* searching the last '/' and '.' in inputFileAssignmentName */
+ char_p = inputFileName;
+ slash_p = inputFileName;
+ while ((char_p = strchr (char_p, '/')))
+ {
+ char_p++;
+ slash_p = char_p;
+ }
+
+ char_p = slash_p;
+ dot_p = inputFileName + strlen (inputFileName);
+
+ while ((char_p = strchr (char_p, '.')))
+ {
+ dot_p = char_p;
+ char_p++;
+ }
+
+ /* outputFileName= inputFileName + .out */
+ *outputFileName = (char *) malloc (dot_p - inputFileName + 1 +
+ strlen (".out"));
+ memcpy (*outputFileName, inputFileName, dot_p - inputFileName);
+ (*outputFileName)[dot_p - inputFileName] = 0;
+ strcat (*outputFileName, ".out");
+ return;
}
/* Description: */
/********************************************************/
int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
{
- static struct option long_options[] =
- {
- {"help", no_argument, 0, 'h'},
- {"version", no_argument, 0, 'v'},
- {"check", no_argument, 0, 'c'},
- {"output", required_argument, 0, 'o'},
+ static 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_TYPE definitions=ASN1_TYPE_EMPTY;
- ASN1_TYPE structure=ASN1_TYPE_EMPTY;
- 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;
-
- 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 */
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- exit(0);
- break;
- case 'v': /* VERSION */
- version_etc (stdout, program_name, PACKAGE, VERSION,
- "Fabio Fiorina", NULL);
- if(outputFileName) 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 */
- fprintf(stderr,"asn1Coding: option '%s' not recognized or without argument.\n\n",argv[optind-1]);
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- exit(1);
- break;
- default:
- fprintf(stderr,"asn1Coding: ?? getopt returned character code Ox%x ??\n",option_result);
- }
- }
-
- if(optind == argc){
- fprintf(stderr,"asn1Coding: input file with ASN1 definitions missing.\n");
- fprintf(stderr," input file with assignments missing.\n\n");
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- exit(1);
- }
-
- if(optind == argc-1){
- fprintf(stderr,"asn1Coding: input file with assignments missing.\n\n");
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- exit(1);
- }
-
- 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:
- printf("Parse: done.\n");
- break;
- case ASN1_FILE_NOT_FOUND:
- printf("asn1Coding: FILE %s NOT FOUND\n",inputFileAsnName);
- break;
- case ASN1_SYNTAX_ERROR:
- case ASN1_IDENTIFIER_NOT_FOUND:
- case ASN1_NAME_TOO_LONG:
- printf("asn1Coding: %s\n",errorDescription);
- break;
- default:
- printf("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){
- printf("asn1Coding: file '%s' not found\n",inputFileAssignmentName);
- free(inputFileAsnName);
- free(inputFileAssignmentName);
- exit(1);
- }
-
-
- printf("\n");
-
- while(readAssignment(inputFile,varName,value) == ASSIGNMENT_SUCCESS){
- printf("var=%s, value=%s\n",varName,value);
- if(structure==ASN1_TYPE_EMPTY){
- asn1_result=asn1_create_element(definitions,value,&structure);
- }
- else
- asn1_result=asn1_write_value(structure,varName,value,0);
-
- if(asn1_result != ASN1_SUCCESS){
- printf("libtasn1 ERROR: %s\n",asn1_strerror(asn1_result));
-
- asn1_delete_structure(&definitions);
- asn1_delete_structure(&structure);
-
- free(inputFileAsnName);
- free(inputFileAssignmentName);
-
- fclose(inputFile);
- exit(1);
- }
- }
- fclose(inputFile);
-
- printf("\n");
- asn1_print_structure(stdout,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,
+ int option_index = 0;
+ int option_result;
+ char *outputFileName = NULL;
+ char *inputFileAsnName = NULL;
+ char *inputFileAssignmentName = NULL;
+ int checkSyntaxOnly = 0;
+ ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+ ASN1_TYPE structure = ASN1_TYPE_EMPTY;
+ 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;
+
+ 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 */
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ exit (0);
+ break;
+ case 'v': /* VERSION */
+ version_etc (stdout, program_name, PACKAGE, VERSION,
+ "Fabio Fiorina", NULL);
+ if (outputFileName)
+ 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 */
+ fprintf (stderr,
+ "asn1Coding: option '%s' not recognized or without argument.\n\n",
+ argv[optind - 1]);
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ exit (1);
+ break;
+ default:
+ fprintf (stderr,
+ "asn1Coding: ?? getopt returned character code Ox%x ??\n",
+ option_result);
+ }
+ }
+
+ if (optind == argc)
+ {
+ fprintf (stderr,
+ "asn1Coding: input file with ASN1 definitions missing.\n");
+ fprintf (stderr,
+ " input file with assignments missing.\n\n");
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ exit (1);
+ }
+
+ if (optind == argc - 1)
+ {
+ fprintf (stderr,
+ "asn1Coding: input file with assignments missing.\n\n");
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ exit (1);
+ }
+
+ 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:
+ printf ("Parse: done.\n");
+ break;
+ case ASN1_FILE_NOT_FOUND:
+ printf ("asn1Coding: FILE %s NOT FOUND\n", inputFileAsnName);
+ break;
+ case ASN1_SYNTAX_ERROR:
+ case ASN1_IDENTIFIER_NOT_FOUND:
+ case ASN1_NAME_TOO_LONG:
+ printf ("asn1Coding: %s\n", errorDescription);
+ break;
+ default:
+ printf ("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)
+ {
+ printf ("asn1Coding: file '%s' not found\n", inputFileAssignmentName);
+ free (inputFileAsnName);
+ free (inputFileAssignmentName);
+ exit (1);
+ }
+
+
+ printf ("\n");
+
+ while (readAssignment (inputFile, varName, value) == ASSIGNMENT_SUCCESS)
+ {
+ printf ("var=%s, value=%s\n", varName, value);
+ if (structure == ASN1_TYPE_EMPTY)
+ {
+ asn1_result = asn1_create_element (definitions, value, &structure);
+ }
+ else
+ asn1_result = asn1_write_value (structure, varName, value, 0);
+
+ if (asn1_result != ASN1_SUCCESS)
+ {
+ printf ("libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
+
+ asn1_delete_structure (&definitions);
+ asn1_delete_structure (&structure);
+
+ free (inputFileAsnName);
+ free (inputFileAssignmentName);
+
+ fclose (inputFile);
+ exit (1);
+ }
+ }
+ fclose (inputFile);
+
+ printf ("\n");
+ asn1_print_structure (stdout, structure, "", ASN1_PRINT_NAME_TYPE_VALUE);
+
+ der_len = 0;
+ asn1_result = asn1_der_coding (structure, "", der, &der_len,
errorDescription);
- }
- printf("\nCoding: %s\n\n",asn1_strerror(asn1_result));
- if(asn1_result!=ASN1_SUCCESS){
- printf("asn1Coding: %s\n",errorDescription);
-
- if (der)
- free (der);
-
- asn1_delete_structure(&definitions);
- asn1_delete_structure(&structure);
-
- free(inputFileAsnName);
- free(inputFileAssignmentName);
-
- exit(1);
- }
-
- /* Print the 'Certificate1' DER encoding */
- printf("-----------------\nNumber of bytes=%i\n",der_len);
- for(k=0;k<der_len;k++) printf("%02x ",der[k]);
- printf("\n-----------------\n");
-
- asn1_delete_structure(&definitions);
- asn1_delete_structure(&structure);
-
-
- if(outputFileName==NULL)
- createFileName(inputFileAssignmentName,&outputFileName);
-
- printf("\nOutputFile=%s\n",outputFileName);
-
- outputFile=fopen(outputFileName,"w");
-
- if(outputFile==NULL){
- printf("asn1Coding: output file '%s' not available\n",outputFileName);
- if (der)
- free (der);
- free(inputFileAsnName);
- free(inputFileAssignmentName);
- free(outputFileName);
- exit(1);
- }
-
- for(k=0;k<der_len;k++)
- fprintf(outputFile,"%c",der[k]);
- fclose(outputFile);
- printf("\nWriting: done.\n");
-
- if (der)
- free (der);
-
- free(inputFileAsnName);
- free(inputFileAssignmentName);
- free(outputFileName);
-
- exit(0);
+ if (asn1_result == ASN1_MEM_ERROR)
+ {
+ der = malloc (der_len);
+ asn1_result = asn1_der_coding (structure, "", der, &der_len,
+ errorDescription);
+ }
+ printf ("\nCoding: %s\n\n", asn1_strerror (asn1_result));
+ if (asn1_result != ASN1_SUCCESS)
+ {
+ printf ("asn1Coding: %s\n", errorDescription);
+
+ if (der)
+ free (der);
+
+ asn1_delete_structure (&definitions);
+ asn1_delete_structure (&structure);
+
+ free (inputFileAsnName);
+ free (inputFileAssignmentName);
+
+ exit (1);
+ }
+
+ /* Print the 'Certificate1' DER encoding */
+ printf ("-----------------\nNumber of bytes=%i\n", der_len);
+ for (k = 0; k < der_len; k++)
+ printf ("%02x ", der[k]);
+ printf ("\n-----------------\n");
+
+ asn1_delete_structure (&definitions);
+ asn1_delete_structure (&structure);
+
+
+ if (outputFileName == NULL)
+ createFileName (inputFileAssignmentName, &outputFileName);
+
+ printf ("\nOutputFile=%s\n", outputFileName);
+
+ outputFile = fopen (outputFileName, "w");
+
+ if (outputFile == NULL)
+ {
+ printf ("asn1Coding: output file '%s' not available\n", outputFileName);
+ if (der)
+ free (der);
+ free (inputFileAsnName);
+ free (inputFileAssignmentName);
+ free (outputFileName);
+ exit (1);
+ }
+
+ for (k = 0; k < der_len; k++)
+ fprintf (outputFile, "%c", der[k]);
+ fclose (outputFile);
+ printf ("\nWriting: done.\n");
+
+ if (der)
+ free (der);
+
+ free (inputFileAsnName);
+ free (inputFileAssignmentName);
+ free (outputFileName);
+
+ exit (0);
}
" -c, --check checks the syntax only\n"
" -h, --help display this help and exit\n"
" -v, --version output version information and exit.\n"
- "\n"
- "Report bugs to <" PACKAGE_BUGREPORT ">.";
+ "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.";
/********************************************************/
/* Function : main */
/* Description: */
/********************************************************/
int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
{
- static struct option long_options[] =
- {
- {"help", no_argument, 0, 'h'},
- {"version", no_argument, 0, 'v'},
- {"check", no_argument, 0, 'c'},
+ static struct option long_options[] = {
+ {"help", no_argument, 0, 'h'},
+ {"version", no_argument, 0, 'v'},
+ {"check", no_argument, 0, 'c'},
{0, 0, 0, 0}
};
- int option_index = 0;
- int option_result;
- char *inputFileAsnName=NULL;
- char *inputFileDerName=NULL;
- char *typeName=NULL;
- int checkSyntaxOnly=0;
- ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
- ASN1_TYPE structure=ASN1_TYPE_EMPTY;
- char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- int asn1_result=ASN1_SUCCESS;
- unsigned char *der;
- int der_len=0;
- /* FILE *outputFile; */
-
- set_program_name (argv[0]);
-
- opterr=0; /* disable error messages from getopt */
-
- while(1){
-
- option_result=getopt_long(argc,argv,"hvc",long_options,&option_index);
-
- if(option_result == -1) break;
-
- switch(option_result){
- case 'h': /* HELP */
- printf("%s\n",help_man);
- exit(0);
- break;
- case 'v': /* VERSION */
- version_etc (stdout, program_name, PACKAGE, VERSION,
- "Fabio Fiorina", NULL);
- exit(0);
- break;
- case 'c': /* CHECK SYNTAX */
- checkSyntaxOnly = 1;
- break;
- case '?': /* UNKNOW OPTION */
- fprintf(stderr,"asn1Decoding: option '%s' not recognized or without argument.\n\n",argv[optind-1]);
- printf("%s\n",help_man);
-
- exit(1);
- break;
- default:
- fprintf(stderr,"asn1Decoding: ?? getopt returned character code Ox%x ??\n",option_result);
- }
- }
-
- if(optind == argc){
- fprintf(stderr,"asn1Decoding: input file with ASN1 definitions missing.\n");
- fprintf(stderr," input file with DER coding missing.\n");
- fprintf(stderr," ASN1 type name missing.\n\n");
- printf("%s\n",help_man);
-
- exit(1);
- }
-
- if(optind == argc-1){
- fprintf(stderr,"asn1Decoding: input file with DER coding missing.\n\n");
- fprintf(stderr," ASN1 type name missing.\n\n");
- printf("%s\n",help_man);
-
- exit(1);
- }
-
- if(optind == argc-2){
- fprintf(stderr,"asn1Decoding: ASN1 type name missing.\n\n");
- printf("%s\n",help_man);
-
- exit(1);
- }
-
- inputFileAsnName=(char *)malloc(strlen(argv[optind])+1);
- strcpy(inputFileAsnName,argv[optind]);
-
- inputFileDerName=(char *)malloc(strlen(argv[optind+1])+1);
- strcpy(inputFileDerName,argv[optind+1]);
-
- typeName=(char *)malloc(strlen(argv[optind+2])+1);
- strcpy(typeName,argv[optind+2]);
-
- asn1_result=asn1_parser2tree(inputFileAsnName,&definitions,errorDescription);
-
- switch(asn1_result){
- case ASN1_SUCCESS:
- printf("Parse: done.\n");
- break;
- case ASN1_FILE_NOT_FOUND:
- printf("asn1Decoding: FILE %s NOT FOUND\n",inputFileAsnName);
- break;
- case ASN1_SYNTAX_ERROR:
- case ASN1_IDENTIFIER_NOT_FOUND:
- case ASN1_NAME_TOO_LONG:
- printf("asn1Decoding: %s\n",errorDescription);
- break;
- default:
- printf("libtasn1 ERROR: %s\n",asn1_strerror(asn1_result));
- }
-
- if(asn1_result != ASN1_SUCCESS){
- free(inputFileAsnName);
- free(inputFileDerName);
- free(typeName);
- exit(1);
- }
-
-
- {
- size_t tmplen;
- der = (unsigned char*) read_binary_file (inputFileDerName, &tmplen);
- der_len = tmplen;
- }
-
- if(der==NULL){
- printf("asn1Decoding: could not read '%s'\n",inputFileDerName);
- asn1_delete_structure(&definitions);
-
- free(inputFileAsnName);
- free(inputFileDerName);
- free(typeName);
- exit(1);
- }
+ int option_index = 0;
+ int option_result;
+ char *inputFileAsnName = NULL;
+ char *inputFileDerName = NULL;
+ char *typeName = NULL;
+ int checkSyntaxOnly = 0;
+ ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+ ASN1_TYPE structure = ASN1_TYPE_EMPTY;
+ char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+ int asn1_result = ASN1_SUCCESS;
+ unsigned char *der;
+ int der_len = 0;
+ /* FILE *outputFile; */
+
+ set_program_name (argv[0]);
+
+ opterr = 0; /* disable error messages from getopt */
+
+ while (1)
+ {
+
+ option_result =
+ getopt_long (argc, argv, "hvc", long_options, &option_index);
+
+ if (option_result == -1)
+ break;
+
+ switch (option_result)
+ {
+ case 'h': /* HELP */
+ printf ("%s\n", help_man);
+ exit (0);
+ break;
+ case 'v': /* VERSION */
+ version_etc (stdout, program_name, PACKAGE, VERSION,
+ "Fabio Fiorina", NULL);
+ exit (0);
+ break;
+ case 'c': /* CHECK SYNTAX */
+ checkSyntaxOnly = 1;
+ break;
+ case '?': /* UNKNOW OPTION */
+ fprintf (stderr,
+ "asn1Decoding: option '%s' not recognized or without argument.\n\n",
+ argv[optind - 1]);
+ printf ("%s\n", help_man);
+
+ exit (1);
+ break;
+ default:
+ fprintf (stderr,
+ "asn1Decoding: ?? getopt returned character code Ox%x ??\n",
+ option_result);
+ }
+ }
+
+ if (optind == argc)
+ {
+ fprintf (stderr,
+ "asn1Decoding: input file with ASN1 definitions missing.\n");
+ fprintf (stderr, " input file with DER coding missing.\n");
+ fprintf (stderr, " ASN1 type name missing.\n\n");
+ printf ("%s\n", help_man);
+
+ exit (1);
+ }
+
+ if (optind == argc - 1)
+ {
+ fprintf (stderr,
+ "asn1Decoding: input file with DER coding missing.\n\n");
+ fprintf (stderr, " ASN1 type name missing.\n\n");
+ printf ("%s\n", help_man);
+
+ exit (1);
+ }
+
+ if (optind == argc - 2)
+ {
+ fprintf (stderr, "asn1Decoding: ASN1 type name missing.\n\n");
+ printf ("%s\n", help_man);
+
+ exit (1);
+ }
+
+ inputFileAsnName = (char *) malloc (strlen (argv[optind]) + 1);
+ strcpy (inputFileAsnName, argv[optind]);
+
+ inputFileDerName = (char *) malloc (strlen (argv[optind + 1]) + 1);
+ strcpy (inputFileDerName, argv[optind + 1]);
+
+ typeName = (char *) malloc (strlen (argv[optind + 2]) + 1);
+ strcpy (typeName, argv[optind + 2]);
+
+ asn1_result =
+ asn1_parser2tree (inputFileAsnName, &definitions, errorDescription);
+
+ switch (asn1_result)
+ {
+ case ASN1_SUCCESS:
+ printf ("Parse: done.\n");
+ break;
+ case ASN1_FILE_NOT_FOUND:
+ printf ("asn1Decoding: FILE %s NOT FOUND\n", inputFileAsnName);
+ break;
+ case ASN1_SYNTAX_ERROR:
+ case ASN1_IDENTIFIER_NOT_FOUND:
+ case ASN1_NAME_TOO_LONG:
+ printf ("asn1Decoding: %s\n", errorDescription);
+ break;
+ default:
+ printf ("libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
+ }
+
+ if (asn1_result != ASN1_SUCCESS)
+ {
+ free (inputFileAsnName);
+ free (inputFileDerName);
+ free (typeName);
+ exit (1);
+ }
- /*****************************************/
- /* ONLY FOR TEST */
- /*****************************************/
- /*
- der_len=0;
- outputFile=fopen("data.p12","w");
- while(fscanf(inputFile,"%c",der+der_len) != EOF){
- if((der_len>=0x11) && (der_len<=(0xe70)))
- fprintf(outputFile,"%c",der[der_len]);
- der_len++;
- }
- fclose(outputFile);
- fclose(inputFile);
- */
-
- asn1_result=asn1_create_element(definitions,typeName,&structure);
+ {
+ size_t tmplen;
+ der = (unsigned char *) read_binary_file (inputFileDerName, &tmplen);
+ der_len = tmplen;
+ }
- /* asn1_print_structure(stdout,structure,"",ASN1_PRINT_ALL); */
+ if (der == NULL)
+ {
+ printf ("asn1Decoding: could not read '%s'\n", inputFileDerName);
+ asn1_delete_structure (&definitions);
+ free (inputFileAsnName);
+ free (inputFileDerName);
+ free (typeName);
+ exit (1);
+ }
- if(asn1_result != ASN1_SUCCESS){
- printf("Structure creation: %s\n",asn1_strerror(asn1_result));
- asn1_delete_structure(&definitions);
- free(inputFileAsnName);
- free(inputFileDerName);
- free(typeName);
- free(der);
- exit(1);
- }
+ /*****************************************/
+ /* ONLY FOR TEST */
+ /*****************************************/
+ /*
+ der_len=0;
+ outputFile=fopen("data.p12","w");
+ while(fscanf(inputFile,"%c",der+der_len) != EOF){
+ if((der_len>=0x11) && (der_len<=(0xe70)))
+ fprintf(outputFile,"%c",der[der_len]);
+ der_len++;
+ }
+ fclose(outputFile);
+ fclose(inputFile);
+ */
- asn1_result=asn1_der_decoding(&structure,der,der_len,errorDescription);
- printf("\nDecoding: %s\n",asn1_strerror(asn1_result));
- if(asn1_result != ASN1_SUCCESS)
- printf("asn1Decoding: %s\n",errorDescription);
+ asn1_result = asn1_create_element (definitions, typeName, &structure);
- printf("\nDECODING RESULT:\n");
- asn1_print_structure(stdout,structure,"",ASN1_PRINT_NAME_TYPE_VALUE);
+ /* asn1_print_structure(stdout,structure,"",ASN1_PRINT_ALL); */
- /*****************************************/
- /* ONLY FOR TEST */
- /*****************************************/
- /*
- der_len=10000;
- option_index=0;
- asn1_result=asn1_read_value(structure,"?2.content",der,&der_len);
- outputFile=fopen("encryptedData.p12","w");
- while(der_len>0){
- fprintf(outputFile,"%c",der[option_index]);
- der_len--;
- option_index++;
- }
- fclose(outputFile);
- */
- asn1_delete_structure(&definitions);
- asn1_delete_structure(&structure);
+ if (asn1_result != ASN1_SUCCESS)
+ {
+ printf ("Structure creation: %s\n", asn1_strerror (asn1_result));
+ asn1_delete_structure (&definitions);
- free(der);
+ free (inputFileAsnName);
+ free (inputFileDerName);
+ free (typeName);
+ free (der);
+ exit (1);
+ }
- free(inputFileAsnName);
- free(inputFileDerName);
- free(typeName);
+ asn1_result =
+ asn1_der_decoding (&structure, der, der_len, errorDescription);
+ printf ("\nDecoding: %s\n", asn1_strerror (asn1_result));
+ if (asn1_result != ASN1_SUCCESS)
+ printf ("asn1Decoding: %s\n", errorDescription);
- if(asn1_result != ASN1_SUCCESS)
- exit(1);
+ printf ("\nDECODING RESULT:\n");
+ asn1_print_structure (stdout, structure, "", ASN1_PRINT_NAME_TYPE_VALUE);
- exit(0);
+ /*****************************************/
+ /* ONLY FOR TEST */
+ /*****************************************/
+ /*
+ der_len=10000;
+ option_index=0;
+ asn1_result=asn1_read_value(structure,"?2.content",der,&der_len);
+ outputFile=fopen("encryptedData.p12","w");
+ while(der_len>0){
+ fprintf(outputFile,"%c",der[option_index]);
+ der_len--;
+ option_index++;
+ }
+ fclose(outputFile);
+ */
+
+ asn1_delete_structure (&definitions);
+ asn1_delete_structure (&structure);
+
+ free (der);
+
+ free (inputFileAsnName);
+ free (inputFileDerName);
+ free (typeName);
+
+ if (asn1_result != ASN1_SUCCESS)
+ exit (1);
+
+ exit (0);
}
" -n, --name NAME array name\n"
" -h, --help display this help and exit\n"
" -v, --version output version information and exit.\n"
- "\n"
- "Report bugs to <" PACKAGE_BUGREPORT ">.";
+ "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.";
/********************************************************/
/* Function : main */
/* Description: */
/********************************************************/
int
-main(int argc,char *argv[])
+main (int argc, char *argv[])
{
- static struct option long_options[] =
- {
- {"help", no_argument, 0, 'h'},
- {"version", no_argument, 0, 'v'},
- {"check", no_argument, 0, 'c'},
- {"output", required_argument, 0, 'o'},
- {"name", required_argument, 0, 'n'},
+ static struct option long_options[] = {
+ {"help", no_argument, 0, 'h'},
+ {"version", no_argument, 0, 'v'},
+ {"check", no_argument, 0, 'c'},
+ {"output", required_argument, 0, 'o'},
+ {"name", required_argument, 0, 'n'},
{0, 0, 0, 0}
};
int option_index = 0;
- int option_result;
- char *outputFileName=NULL;
- char *inputFileName=NULL;
- char *vectorName=NULL;
- int checkSyntaxOnly=0;
- ASN1_TYPE pointer=ASN1_TYPE_EMPTY;
- char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- int parse_result=ASN1_SUCCESS;
-
- set_program_name (argv[0]);
-
- opterr=0; /* disable error messages from getopt */
-
- while(1){
-
- option_result=getopt_long(argc,argv,"hvco:n:",long_options,&option_index);
-
- if(option_result == -1) break;
-
- switch(option_result){
- case 0:
- printf("option %s",long_options[option_index].name);
- if(optarg) printf(" with arg %s",optarg);
- printf("\n");
- break;
- case 'h': /* HELP */
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- if(vectorName) free(vectorName);
- exit(0);
- break;
- case 'v': /* VERSION */
- version_etc (stdout, program_name, PACKAGE, VERSION,
- "Fabio Fiorina", NULL);
- if(outputFileName) free(outputFileName);
- if(vectorName) free(vectorName);
- exit(0);
- break;
- case 'c': /* CHECK SYNTAX */
- checkSyntaxOnly = 1;
- break;
- case 'o': /* OUTPUT */
- outputFileName=(char *)malloc(strlen(optarg)+1);
- strcpy(outputFileName,optarg);
- break;
- case 'n': /* VECTOR NAME */
- vectorName=(char *)malloc(strlen(optarg)+1);
- strcpy(vectorName,optarg);
- break;
- case '?': /* UNKNOW OPTION */
- fprintf(stderr,"asn1Parser: option '%s' not recognized or without argument.\n\n",argv[optind-1]);
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- if(vectorName) free(vectorName);
- exit(1);
- break;
- default:
- fprintf(stderr,"asn1Parser: ?? getopt returned character code Ox%x ??\n",option_result);
- }
-
- }
-
- if(optind == argc){
- fprintf(stderr,"asn1Parser: input file name missing.\n\n");
- printf("%s\n",help_man);
-
- if(outputFileName) free(outputFileName);
- if(vectorName) free(vectorName);
- exit(1);
- }
- else{
- inputFileName=(char *)malloc(strlen(argv[optind])+1);
- strcpy(inputFileName,argv[optind]);
- }
-
- if(checkSyntaxOnly == 1){
- parse_result=asn1_parser2tree(inputFileName,&pointer,errorDescription);
- asn1_delete_structure(&pointer);
- }
- else /* C VECTOR CREATION */
- parse_result=asn1_parser2array(inputFileName,
- outputFileName,vectorName,errorDescription);
-
- switch(parse_result){
- case ASN1_SUCCESS:
- printf("Done.\n");
- break;
- case ASN1_FILE_NOT_FOUND:
- printf("asn1Parser: FILE %s NOT FOUND\n",inputFileName);
- break;
- case ASN1_SYNTAX_ERROR:
- case ASN1_IDENTIFIER_NOT_FOUND:
- case ASN1_NAME_TOO_LONG:
- printf("asn1Parser: %s\n",errorDescription);
- break;
- default:
- printf("libtasn1 ERROR: %s\n",asn1_strerror(parse_result));
- }
-
-
- free(inputFileName);
- if(outputFileName) free(outputFileName);
- if(vectorName) free(vectorName);
-
- if(parse_result != ASN1_SUCCESS) exit(1);
- exit(0);
+ int option_result;
+ char *outputFileName = NULL;
+ char *inputFileName = NULL;
+ char *vectorName = NULL;
+ int checkSyntaxOnly = 0;
+ ASN1_TYPE pointer = ASN1_TYPE_EMPTY;
+ char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+ int parse_result = ASN1_SUCCESS;
+
+ set_program_name (argv[0]);
+
+ opterr = 0; /* disable error messages from getopt */
+
+ while (1)
+ {
+
+ option_result =
+ getopt_long (argc, argv, "hvco:n:", long_options, &option_index);
+
+ if (option_result == -1)
+ break;
+
+ switch (option_result)
+ {
+ case 0:
+ printf ("option %s", long_options[option_index].name);
+ if (optarg)
+ printf (" with arg %s", optarg);
+ printf ("\n");
+ break;
+ case 'h': /* HELP */
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ if (vectorName)
+ free (vectorName);
+ exit (0);
+ break;
+ case 'v': /* VERSION */
+ version_etc (stdout, program_name, PACKAGE, VERSION,
+ "Fabio Fiorina", NULL);
+ if (outputFileName)
+ free (outputFileName);
+ if (vectorName)
+ free (vectorName);
+ exit (0);
+ break;
+ case 'c': /* CHECK SYNTAX */
+ checkSyntaxOnly = 1;
+ break;
+ case 'o': /* OUTPUT */
+ outputFileName = (char *) malloc (strlen (optarg) + 1);
+ strcpy (outputFileName, optarg);
+ break;
+ case 'n': /* VECTOR NAME */
+ vectorName = (char *) malloc (strlen (optarg) + 1);
+ strcpy (vectorName, optarg);
+ break;
+ case '?': /* UNKNOW OPTION */
+ fprintf (stderr,
+ "asn1Parser: option '%s' not recognized or without argument.\n\n",
+ argv[optind - 1]);
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ if (vectorName)
+ free (vectorName);
+ exit (1);
+ break;
+ default:
+ fprintf (stderr,
+ "asn1Parser: ?? getopt returned character code Ox%x ??\n",
+ option_result);
+ }
+
+ }
+
+ if (optind == argc)
+ {
+ fprintf (stderr, "asn1Parser: input file name missing.\n\n");
+ printf ("%s\n", help_man);
+
+ if (outputFileName)
+ free (outputFileName);
+ if (vectorName)
+ free (vectorName);
+ exit (1);
+ }
+ else
+ {
+ inputFileName = (char *) malloc (strlen (argv[optind]) + 1);
+ strcpy (inputFileName, argv[optind]);
+ }
+
+ if (checkSyntaxOnly == 1)
+ {
+ parse_result =
+ asn1_parser2tree (inputFileName, &pointer, errorDescription);
+ asn1_delete_structure (&pointer);
+ }
+ else /* C VECTOR CREATION */
+ parse_result = asn1_parser2array (inputFileName,
+ outputFileName, vectorName,
+ errorDescription);
+
+ switch (parse_result)
+ {
+ case ASN1_SUCCESS:
+ printf ("Done.\n");
+ break;
+ case ASN1_FILE_NOT_FOUND:
+ printf ("asn1Parser: FILE %s NOT FOUND\n", inputFileName);
+ break;
+ case ASN1_SYNTAX_ERROR:
+ case ASN1_IDENTIFIER_NOT_FOUND:
+ case ASN1_NAME_TOO_LONG:
+ printf ("asn1Parser: %s\n", errorDescription);
+ break;
+ default:
+ printf ("libtasn1 ERROR: %s\n", asn1_strerror (parse_result));
+ }
+
+
+ free (inputFileName);
+ if (outputFileName)
+ free (outputFileName);
+ if (vectorName)
+ free (vectorName);
+
+ if (parse_result != ASN1_SUCCESS)
+ exit (1);
+ exit (0);
}
-int
-main(int argc,char *argv[])
+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 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;
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);
+ 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);
- }
+ 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);
+ asn1_delete_structure (&definitions);
+ asn1_delete_structure (&asn1_element);
- if(out != stdout) fclose(out);
+ if (out != stdout)
+ fclose (out);
- exit(0);
+ exit (0);
}
-
-
-
-
-
-
-
-
-
#include <stdlib.h>
#include "libtasn1.h"
-typedef struct{
+typedef struct
+{
int lineNumber;
char *line;
- int errorNumber;
+ int errorNumber;
char *errorDescription;
} test_type;
char *fileCorrectName;
-char fileErroredName[]="Test_parser_ERROR.asn";
+char fileErroredName[] = "Test_parser_ERROR.asn";
#define _FILE_ "Test_parser_ERROR.asn"
-test_type test_array[]={
+test_type test_array[] = {
/* Test DEFINITIONS syntax */
- {5,"TEST_PARSER2 { } DEFINITIONS IMPLICIT TAGS ::= BEGIN int1 ::= INTEGER END",
- ASN1_SYNTAX_ERROR,_FILE_":6: parse error near 'TEST_PARSER'"},
- {6,"TEST_PARSER { }",ASN1_SUCCESS,""},
+ {5,
+ "TEST_PARSER2 { } DEFINITIONS IMPLICIT TAGS ::= BEGIN int1 ::= INTEGER END",
+ ASN1_SYNTAX_ERROR, _FILE_ ":6: parse error near 'TEST_PARSER'"},
+ {6, "TEST_PARSER { }", ASN1_SUCCESS, ""},
/* Test ASN1_MAX_NAME_SIZE (128) */
- {12,"a1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567 ::= INTEGER",
- ASN1_SUCCESS,""},
- {12,"a12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678 ::= INTEGER",
- ASN1_NAME_TOO_LONG,_FILE_":12: name too long (more than 128 characters)"},
+ {12,
+ "a1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567 ::= INTEGER",
+ ASN1_SUCCESS, ""},
+ {12,
+ "a12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678 ::= INTEGER",
+ ASN1_NAME_TOO_LONG,
+ _FILE_ ":12: name too long (more than 128 characters)"},
/* Test 'check identifier' function */
- {12,"ident1 ::= ident2 ident2 ::= INTEGER",
- ASN1_SUCCESS,""},
- {12,"ident1 ::= ident2",
- ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'ident2' not found"},
- {12,"obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4} "
- "pkix OBJECT IDENTIFIER ::= {1 2}",
- ASN1_SUCCESS,""},
- {12,"obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4}",
- ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'pkix' not found"},
+ {12, "ident1 ::= ident2 ident2 ::= INTEGER",
+ ASN1_SUCCESS, ""},
+ {12, "ident1 ::= ident2",
+ ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier 'ident2' not found"},
+ {12, "obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4} "
+ "pkix OBJECT IDENTIFIER ::= {1 2}",
+ ASN1_SUCCESS, ""},
+ {12, "obj1 OBJECT IDENTIFIER ::= {pkix 0 5 4}",
+ ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier 'pkix' not found"},
/* Test INTEGER */
- {14,"int1 INTEGER OPTIONAL,",ASN1_SUCCESS,""},
- {14,"int1 INTEGER DEFAULT 1,",ASN1_SUCCESS,""},
- {14,"int1 INTEGER DEFAULT -1,",ASN1_SUCCESS,""},
- {14,"int1 INTEGER DEFAULT v1,",ASN1_SUCCESS,""},
- {14,"int1 [1] INTEGER,",ASN1_SUCCESS,""},
- {14,"int1 [1] EXPLICIT INTEGER,",ASN1_SUCCESS,""},
- {14,"int1 [1] IMPLICIT INTEGER,",ASN1_SUCCESS,""},
- {12,"Integer ::= [1] EXPLICIT INTEGER {v1(-1), v2(1)}",ASN1_SUCCESS,""},
- {12,"Integer ::= INTEGER {v1(0), v2}",
- ASN1_SYNTAX_ERROR,_FILE_":12: parse error near '}'"},
- {12,"Integer ::= INTEGER {v1(0), 1}",
- ASN1_SYNTAX_ERROR,_FILE_":12: parse error near '1'"},
- {12,"const1 INTEGER ::= -1",ASN1_SUCCESS,""},
- {12,"const1 INTEGER ::= 1",ASN1_SUCCESS,""},
- {12,"const1 INTEGER ::= v1",
- ASN1_SYNTAX_ERROR,_FILE_":12: parse error near 'v1'"},
- {16," generic generalstring",
- ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'generalstring' not found"},
+ {14, "int1 INTEGER OPTIONAL,", ASN1_SUCCESS, ""},
+ {14, "int1 INTEGER DEFAULT 1,", ASN1_SUCCESS, ""},
+ {14, "int1 INTEGER DEFAULT -1,", ASN1_SUCCESS, ""},
+ {14, "int1 INTEGER DEFAULT v1,", ASN1_SUCCESS, ""},
+ {14, "int1 [1] INTEGER,", ASN1_SUCCESS, ""},
+ {14, "int1 [1] EXPLICIT INTEGER,", ASN1_SUCCESS, ""},
+ {14, "int1 [1] IMPLICIT INTEGER,", ASN1_SUCCESS, ""},
+ {12, "Integer ::= [1] EXPLICIT INTEGER {v1(-1), v2(1)}", ASN1_SUCCESS, ""},
+ {12, "Integer ::= INTEGER {v1(0), v2}",
+ ASN1_SYNTAX_ERROR, _FILE_ ":12: parse error near '}'"},
+ {12, "Integer ::= INTEGER {v1(0), 1}",
+ ASN1_SYNTAX_ERROR, _FILE_ ":12: parse error near '1'"},
+ {12, "const1 INTEGER ::= -1", ASN1_SUCCESS, ""},
+ {12, "const1 INTEGER ::= 1", ASN1_SUCCESS, ""},
+ {12, "const1 INTEGER ::= v1",
+ ASN1_SYNTAX_ERROR, _FILE_ ":12: parse error near 'v1'"},
+ {16, " generic generalstring",
+ ASN1_IDENTIFIER_NOT_FOUND,
+ _FILE_ ":: identifier 'generalstring' not found"},
/* Test: OID */
- {20," oid1 OBJECT IDENTIFIER DEFAULT Oid-type",
- ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier 'Oid-type' not found"},
- {20," oid1 OBJECT IDENTIFIER DEFAULT 1",
- ASN1_IDENTIFIER_NOT_FOUND,_FILE_":: identifier '1' not found"},
- {20," oid1 OBJECT IDENTIFIER DEFAULT",
- ASN1_SYNTAX_ERROR,_FILE_":21: parse error near '}'"},
- {20," oid1 OBJECT IDENTIFIER DEFAULT Oid-type1",
- ASN1_SUCCESS,""},
+ {20, " oid1 OBJECT IDENTIFIER DEFAULT Oid-type",
+ ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier 'Oid-type' not found"},
+ {20, " oid1 OBJECT IDENTIFIER DEFAULT 1",
+ ASN1_IDENTIFIER_NOT_FOUND, _FILE_ ":: identifier '1' not found"},
+ {20, " oid1 OBJECT IDENTIFIER DEFAULT",
+ ASN1_SYNTAX_ERROR, _FILE_ ":21: parse error near '}'"},
+ {20, " oid1 OBJECT IDENTIFIER DEFAULT Oid-type1",
+ ASN1_SUCCESS, ""},
/* end */
};
int
-readLine(FILE *file,char *line)
+readLine (FILE * file, char *line)
{
int c;
- while(((c=fgetc(file))!=EOF) && (c!='\n')){
- *line=c;
- line++;
- }
+ while (((c = fgetc (file)) != EOF) && (c != '\n'))
+ {
+ *line = c;
+ line++;
+ }
- *line=0;
+ *line = 0;
return c;
}
void
-createFile(int lineNumber,char *line)
+createFile (int lineNumber, char *line)
{
- FILE *fileIn,*fileOut;
+ FILE *fileIn, *fileOut;
char lineRead[1024];
- int fileInLineNumber=0;
-
- fileIn=fopen(fileCorrectName,"r");
- fileOut=fopen(fileErroredName,"w");
-
- while(readLine(fileIn,lineRead) != EOF){
- fileInLineNumber++;
- if(fileInLineNumber==lineNumber)
- fprintf(fileOut,"%s\n",line);
- else
- fprintf(fileOut,"%s\n",lineRead);
- }
+ int fileInLineNumber = 0;
+
+ fileIn = fopen (fileCorrectName, "r");
+ fileOut = fopen (fileErroredName, "w");
+
+ while (readLine (fileIn, lineRead) != EOF)
+ {
+ fileInLineNumber++;
+ if (fileInLineNumber == lineNumber)
+ fprintf (fileOut, "%s\n", line);
+ else
+ fprintf (fileOut, "%s\n", lineRead);
+ }
- fclose(fileOut);
- fclose(fileIn);
+ fclose (fileOut);
+ fclose (fileIn);
}
-int
-main(int argc,char *argv[])
+int
+main (int argc, char *argv[])
{
asn1_retCode result;
- ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
+ ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
test_type *test;
- int errorCounter=0,testCounter=0;
+ int errorCounter = 0, testCounter = 0;
fileCorrectName = getenv ("ASN1PARSER");
if (!fileCorrectName)
- fileCorrectName="Test_parser.asn";
+ fileCorrectName = "Test_parser.asn";
- printf("\n\n/****************************************/\n");
- printf( "/* Test sequence : Test_parser */\n");
- printf( "/****************************************/\n\n");
- printf("ASN1PARSER: %s\n", fileCorrectName);
+ printf ("\n\n/****************************************/\n");
+ printf ("/* Test sequence : Test_parser */\n");
+ printf ("/****************************************/\n\n");
+ printf ("ASN1PARSER: %s\n", fileCorrectName);
- result=asn1_parser2tree(fileCorrectName,&definitions,errorDescription);
+ 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);
- }
+ 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);
+ asn1_delete_structure (&definitions);
+
+ test = test_array;
- test=test_array;
+ while (test->lineNumber != 0)
+ {
+ testCounter++;
- while(test->lineNumber != 0){
- testCounter++;
+ createFile (test->lineNumber, test->line);
- createFile(test->lineNumber,test->line);
+ result =
+ asn1_parser2tree (fileErroredName, &definitions, errorDescription);
+ asn1_delete_structure (&definitions);
- 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);
+ }
- 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++;
}
-
- test++;
- }
- printf("Total tests : %d\n",testCounter);
- printf("Total errors: %d\n",errorCounter);
+ printf ("Total tests : %d\n", testCounter);
+ printf ("Total errors: %d\n", errorCounter);
- if(errorCounter > 0)
+ if (errorCounter > 0)
return 1;
- exit(0);
+ exit (0);
}
-
-
-
-
-
-
-
#define ACT_DELETE_ELEMENT 21
-typedef struct{
+typedef struct
+{
int action;
char *par1;
unsigned char *par2;
int par3;
- int errorNumber;
+ int errorNumber;
} test_type;
-test_type test_array[]={
+test_type test_array[] = {
- {ACT_DELETE,"","",0,ASN1_ELEMENT_NOT_FOUND},
+ {ACT_DELETE, "", "", 0, ASN1_ELEMENT_NOT_FOUND},
/* Test: APPLICATION 30 */
- {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"pvno","5",0,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,5,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,4,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,5,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_SUCCESS},
- {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_ELEMENT_NOT_FOUND},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.KrbError", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "pvno", "5", 0, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 5, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 4, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 5, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.KrbError", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE_ELEMENT, "pvno", "", 0, ASN1_SUCCESS},
+ {ACT_DELETE_ELEMENT, "pvno", "", 0, ASN1_ELEMENT_NOT_FOUND},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: CHOICE */
- {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"version",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"validity",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer","rdnSequence",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.3",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x18\x71\x75\x61\x73\x61\x72\x2e\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",26,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.7",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x08\x43\x61\x6d\x70\x69\x6e\x61\x73",10,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.6",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x13\x06\x42\x72\x61\x73\x69\x6c",8,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.10",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x02\x49\x43",4,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.11",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x03\x4c\x41\x53",5,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.8",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x09\x53\x61\x6f\x20\x50\x61\x75\x6c\x6f",11,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.type","1.2.840.113549.1.9.1",0,ASN1_SUCCESS},
- {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x16\x19\x65\x64\x75\x61\x72\x64\x6f\x40\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",27,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,152,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,151,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,152,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_SUCCESS},
- {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_ELEMENT_NOT_FOUND},
- {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?3","",0,ASN1_SUCCESS},
- {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?5","",0,ASN1_SUCCESS},
- {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?7","",0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.CertTemplate", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "version", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "validity", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer", "rdnSequence", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.3", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+ "\x0c\x18\x71\x75\x61\x73\x61\x72\x2e\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",
+ 26, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.7", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+ "\x0c\x08\x43\x61\x6d\x70\x69\x6e\x61\x73", 10, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.6", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+ "\x13\x06\x42\x72\x61\x73\x69\x6c", 8, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.10", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value", "\x0c\x02\x49\x43", 4,
+ ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.11", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value", "\x0c\x03\x4c\x41\x53", 5,
+ ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "2.5.4.8", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+ "\x0c\x09\x53\x61\x6f\x20\x50\x61\x75\x6c\x6f", 11, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.type", "1.2.840.113549.1.9.1", 0,
+ ASN1_SUCCESS},
+ {ACT_WRITE, "issuer.rdnSequence.?LAST.value",
+ "\x16\x19\x65\x64\x75\x61\x72\x64\x6f\x40\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",
+ 27, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 152, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 151, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 152, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.CertTemplate", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?1", "", 0, ASN1_SUCCESS},
+ {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?1", "", 0,
+ ASN1_ELEMENT_NOT_FOUND},
+ {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?3", "", 0, ASN1_SUCCESS},
+ {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?5", "", 0, ASN1_SUCCESS},
+ {ACT_DELETE_ELEMENT, "issuer.rdnSequence.?7", "", 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: Empty sequnces */
- {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
- {ACT_WRITE,"seq1.int",NULL,0,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,11,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,10,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,11,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"seq1","START",5,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"seq1","END",6,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"set1","START",7,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"set1","END",10,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.sequenceEmpty", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "int1", "1", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "seq1.int", NULL, 0, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 11, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 10, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 11, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.sequenceEmpty", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "seq1", "START", 5, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "seq1", "END", 6, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "set1", "START", 7, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "set1", "END", 10, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: Indefinite Length */
- {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
- {ACT_WRITE,"seq1.int","2",0,ASN1_SUCCESS},
- {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"set1.?LAST","1.2.3.4",0,ASN1_SUCCESS},
- {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"set1.?LAST","1.2.5.6",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,255,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_SET_DER,"\x30\x18\xa1\x80\x02\x01\x02\x00\x00\x31\x80\x06\x03\x2a\x03\x04\x06\x03\x2a\x05\x06\x00\x00\x02\x01\x01",
- 0,26,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"seq1","START",2,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"seq1","END",8,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"set1","START",9,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"set1","END",22,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.IndefiniteLengthTest", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "int1", "1", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "seq1.int", "2", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set1", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set1.?LAST", "1.2.3.4", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set1", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set1.?LAST", "1.2.5.6", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 255, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_SET_DER,
+ "\x30\x18\xa1\x80\x02\x01\x02\x00\x00\x31\x80\x06\x03\x2a\x03\x04\x06\x03\x2a\x05\x06\x00\x00\x02\x01\x01",
+ 0, 26, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.IndefiniteLengthTest", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "seq1", "START", 2, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "seq1", "END", 8, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "set1", "START", 9, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "set1", "END", 22, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: OID */
- {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
- {ACT_READ_LENGTH,"oid",NULL,9,ASN1_MEM_ERROR},
- {ACT_READ,"oid","2.5.29.2",9,ASN1_SUCCESS},
- {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
- {ACT_WRITE,"oid2","2.5.29.1",0,ASN1_SUCCESS},
- {ACT_WRITE,"oid3","1.2.29.2",0,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"oid","START",2,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"oid","END",6,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"","START",0,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"","END",6,ASN1_SUCCESS},
- {ACT_READ,"oid2","2.5.29.1",9,ASN1_SUCCESS},
- {ACT_READ,"oid3","1.2.29.2",9,ASN1_SUCCESS},
- {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.OidTest", 0, 0, ASN1_SUCCESS},
+ {ACT_READ_LENGTH, "oid", NULL, 9, ASN1_MEM_ERROR},
+ {ACT_READ, "oid", "2.5.29.2", 9, ASN1_SUCCESS},
+ {ACT_WRITE, "oid", "1.2.3.4", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "oid2", "2.5.29.1", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "oid3", "1.2.29.2", 0, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 7, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 6, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 7, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.OidTest", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "oid", "START", 2, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "oid", "END", 6, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "", "START", 0, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "", "END", 6, ASN1_SUCCESS},
+ {ACT_READ, "oid2", "2.5.29.1", 9, ASN1_SUCCESS},
+ {ACT_READ, "oid3", "1.2.29.2", 9, ASN1_SUCCESS},
+ {ACT_WRITE, "oid", "1.2.3.4", 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: ENCODING_LENGTH and READ_LEN */
- {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
- {ACT_WRITE,"time1","9801011200Z",1,ASN1_SUCCESS},
- {ACT_WRITE,"time2","2001010112001.12-0700",1,ASN1_SUCCESS},
- {ACT_WRITE,"oct","ABCD",4,ASN1_SUCCESS},
- {ACT_WRITE,"bol","TRUE",1,ASN1_SUCCESS},
- {ACT_WRITE,"enum","2",0,ASN1_SUCCESS},
- {ACT_WRITE,"bit","1\xC0",10,ASN1_SUCCESS},
- {ACT_WRITE,"any","\x30\x01\x01",3,ASN1_SUCCESS},
- {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"set.?LAST","10",0,ASN1_SUCCESS},
- {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
- {ACT_WRITE,"set.?LAST","1",0,ASN1_SUCCESS},
- {ACT_WRITE,"gen","Prova",5,ASN1_SUCCESS},
- {ACT_READ_LENGTH,"oid",NULL,8,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"time1",NULL,12,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"time2",NULL,22,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"oct",NULL,4,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"bol",NULL,5,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"enum",NULL,1,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"any",NULL,3,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"gen",NULL,5,ASN1_MEM_ERROR},
- {ACT_READ_LENGTH,"bit",NULL,10,ASN1_MEM_ERROR},
- {ACT_READ_BIT,"bit","1\xC0",10,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,79,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,78,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,79,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.OidAndTimeTest", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "oid", "1.2.3.4", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "time1", "9801011200Z", 1, ASN1_SUCCESS},
+ {ACT_WRITE, "time2", "2001010112001.12-0700", 1, ASN1_SUCCESS},
+ {ACT_WRITE, "oct", "ABCD", 4, ASN1_SUCCESS},
+ {ACT_WRITE, "bol", "TRUE", 1, ASN1_SUCCESS},
+ {ACT_WRITE, "enum", "2", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "bit", "1\xC0", 10, ASN1_SUCCESS},
+ {ACT_WRITE, "any", "\x30\x01\x01", 3, ASN1_SUCCESS},
+ {ACT_WRITE, "set", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set.?LAST", "10", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set", "NEW", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "set.?LAST", "1", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "gen", "Prova", 5, ASN1_SUCCESS},
+ {ACT_READ_LENGTH, "oid", NULL, 8, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "time1", NULL, 12, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "time2", NULL, 22, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "oct", NULL, 4, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "bol", NULL, 5, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "enum", NULL, 1, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "any", NULL, 3, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "gen", NULL, 5, ASN1_MEM_ERROR},
+ {ACT_READ_LENGTH, "bit", NULL, 10, ASN1_MEM_ERROR},
+ {ACT_READ_BIT, "bit", "1\xC0", 10, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 79, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 78, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 79, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.OidAndTimeTest", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: OID to STRUCTURE */
- {ACT_OID_2_STRUCTURE,"2.5.29.3","",0,ASN1_ELEMENT_NOT_FOUND},
- {ACT_OID_2_STRUCTURE,"1.2.29.2","",0,ASN1_ELEMENT_NOT_FOUND},
- {ACT_OID_2_STRUCTURE,"2.5.29.2","anyTest2",0,ASN1_SUCCESS},
+ {ACT_OID_2_STRUCTURE, "2.5.29.3", "", 0, ASN1_ELEMENT_NOT_FOUND},
+ {ACT_OID_2_STRUCTURE, "1.2.29.2", "", 0, ASN1_ELEMENT_NOT_FOUND},
+ {ACT_OID_2_STRUCTURE, "2.5.29.2", "anyTest2", 0, ASN1_SUCCESS},
/* Test: READ TAG and CLASS */
- {ACT_CREATE,"TEST_TREE.SequenceTestTag",0,0,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"int","",0,ASN1_ELEMENT_NOT_FOUND},
- {ACT_READ_TAG_CLASS,"int1","TAG",ASN1_TAG_INTEGER,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"int1","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"int2","TAG",3,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"int2","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"str1","TAG",1,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"str1","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"str2","TAG",28,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"str2","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"str3","TAG",28,ASN1_SUCCESS},
- {ACT_READ_TAG_CLASS,"str3","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.SequenceTestTag", 0, 0, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "int", "", 0, ASN1_ELEMENT_NOT_FOUND},
+ {ACT_READ_TAG_CLASS, "int1", "TAG", ASN1_TAG_INTEGER, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "int1", "CLASS", ASN1_CLASS_UNIVERSAL, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "int2", "TAG", 3, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "int2", "CLASS", ASN1_CLASS_CONTEXT_SPECIFIC,
+ ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "str1", "TAG", 1, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "str1", "CLASS", ASN1_CLASS_CONTEXT_SPECIFIC,
+ ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "str2", "TAG", 28, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "str2", "CLASS", ASN1_CLASS_UNIVERSAL, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "str3", "TAG", 28, ASN1_SUCCESS},
+ {ACT_READ_TAG_CLASS, "str3", "CLASS", ASN1_CLASS_UNIVERSAL, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: OBJECT IDENTIFIER elements */
- {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"int1","v2",0,ASN1_SUCCESS},
- {ACT_READ,"int1","\x01",1,ASN1_SUCCESS},
- {ACT_WRITE,"int2","0",0,ASN1_SUCCESS},
- {ACT_WRITE,"oct","\x02\x01\x0a",3,ASN1_SUCCESS},
- {ACT_WRITE,"id","1 2 3 4 5",0,ASN1_VALUE_NOT_VALID},
- {ACT_WRITE,"id","2.5.29.2",0,ASN1_SUCCESS},
- {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
- {ACT_READ_LENGTH,"id",NULL,9,ASN1_MEM_ERROR},
- {ACT_WRITE,"any1","\x02\x01\x05",3,ASN1_SUCCESS},
- {ACT_READ_DEFINITIONS,"TEST_TREE.id-anyTest","2.5.29.1",9,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,20,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,19,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,200,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"id","START",7,ASN1_SUCCESS},
- {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
- {ACT_EXPAND_ANY,"",NULL,0,ASN1_SUCCESS},
- {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "int1", "v2", 0, ASN1_SUCCESS},
+ {ACT_READ, "int1", "\x01", 1, ASN1_SUCCESS},
+ {ACT_WRITE, "int2", "0", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "oct", "\x02\x01\x0a", 3, ASN1_SUCCESS},
+ {ACT_WRITE, "id", "1 2 3 4 5", 0, ASN1_VALUE_NOT_VALID},
+ {ACT_WRITE, "id", "2.5.29.2", 0, ASN1_SUCCESS},
+ {ACT_READ, "id", "2.5.29.2", 9, ASN1_SUCCESS},
+ {ACT_READ_LENGTH, "id", NULL, 9, ASN1_MEM_ERROR},
+ {ACT_WRITE, "any1", "\x02\x01\x05", 3, ASN1_SUCCESS},
+ {ACT_READ_DEFINITIONS, "TEST_TREE.id-anyTest", "2.5.29.1", 9, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 20, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 19, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 200, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "id", "START", 7, ASN1_SUCCESS},
+ {ACT_READ, "id", "2.5.29.2", 9, ASN1_SUCCESS},
+ {ACT_EXPAND_ANY, "", NULL, 0, ASN1_SUCCESS},
+ {ACT_EXPAND_OCTET, "oct", "id", 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Test: CHOICE elements */
- {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"","teletexString",0,ASN1_SUCCESS},
- {ACT_WRITE,"teletexString","PROVA",5,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
-
+ {ACT_CREATE, "TEST_TREE.X520LocalityName", 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "", "teletexString", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "teletexString", "PROVA", 5, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 7, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 6, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 7, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.X520LocalityName", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
/* Test: OPTIONAL elements */
- {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"prime","1",0,ASN1_SUCCESS},
- {ACT_WRITE,"base","2",0,ASN1_SUCCESS},
- {ACT_WRITE,"privateValueLength",NULL,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,8,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,7,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,8,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
-
+ {ACT_CREATE, "TEST_TREE.DHParameter", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "prime", "1", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "base", "2", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "privateValueLength", NULL, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 8, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 7, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 8, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.DHParameter", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
/* Test: Integer */
- {ACT_CREATE,"TEST_TREE.AnyTest2",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"","int",0,ASN1_SUCCESS},
- {ACT_WRITE,"int","0",0,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,3,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,2,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,3,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"int","-1",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"int","1",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"int","2000000000",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"int","-2000000000",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"int","-20000000000",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_WRITE,"int","20000000000",0,ASN1_SUCCESS},
- {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
-
+ {ACT_CREATE, "TEST_TREE.AnyTest2", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "", "int", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "0", 0, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 3, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 2, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 3, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "-1", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "1", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "2000000000", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "-2000000000", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "-20000000000", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_WRITE, "int", "20000000000", 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
/* Test: elements without names */
- {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"int2","10",0,ASN1_SUCCESS},
- {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
- {ACT_WRITE,"seq.?LAST","1",0,ASN1_SUCCESS},
- {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
- {ACT_WRITE,"seq.?LAST","2",0,ASN1_SUCCESS},
- {ACT_WRITE,"any1",NULL,0,ASN1_SUCCESS},
- {ACT_NUMBER_OF_ELEMENTS,"seq","",2,ASN1_SUCCESS},
- {ACT_WRITE,"id","1.2.3.4",0,ASN1_SUCCESS},
- {ACT_WRITE,"oct","\x30\x03\x02\x01\x15",5,ASN1_SUCCESS},
- {ACT_ENCODING,"int2",0,1024,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_ENCODING,"seq.?2",0,2,ASN1_MEM_ERROR},
- {ACT_ENCODING,"seq.?2",0,3,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,25,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,24,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,25,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
- {ACT_DECODING_ELEMENT,"int2",0,0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_READ,"int2","\x0a",1,ASN1_SUCCESS},
- {ACT_READ_LENGTH,"int2",NULL,1,ASN1_MEM_ERROR},
- {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_START_END,"seq.?2","START",10,ASN1_SUCCESS},
- {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
-
+ {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "int2", "10", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "seq", "NEW", 1, ASN1_SUCCESS},
+ {ACT_WRITE, "seq.?LAST", "1", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "seq", "NEW", 1, ASN1_SUCCESS},
+ {ACT_WRITE, "seq.?LAST", "2", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "any1", NULL, 0, ASN1_SUCCESS},
+ {ACT_NUMBER_OF_ELEMENTS, "seq", "", 2, ASN1_SUCCESS},
+ {ACT_WRITE, "id", "1.2.3.4", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "oct", "\x30\x03\x02\x01\x15", 5, ASN1_SUCCESS},
+ {ACT_ENCODING, "int2", 0, 1024, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_ENCODING, "seq.?2", 0, 2, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "seq.?2", 0, 3, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 25, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 24, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 25, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_ELEMENT, "int2", 0, 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_READ, "int2", "\x0a", 1, ASN1_SUCCESS},
+ {ACT_READ_LENGTH, "int2", NULL, 1, ASN1_MEM_ERROR},
+ {ACT_CREATE, "TEST_TREE.Sequence1", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_START_END, "seq.?2", "START", 10, ASN1_SUCCESS},
+ {ACT_EXPAND_OCTET, "oct", "id", 0, ASN1_SUCCESS},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+
/* Test GeneralString */
- {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"a","1234",0,ASN1_SUCCESS},
- {ACT_WRITE,"b","prova",5,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,17,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,16,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,17,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_ELEMENT,"b",0,0,ASN1_SUCCESS},
- {ACT_READ,"b","prova",5,ASN1_SUCCESS},
- {ACT_READ_LENGTH,"b",NULL,5,ASN1_MEM_ERROR},
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Test3", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "a", "1234", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "b", "prova", 5, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 17, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 16, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 17, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Test3", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_ELEMENT, "b", 0, 0, ASN1_SUCCESS},
+ {ACT_READ, "b", "prova", 5, ASN1_SUCCESS},
+ {ACT_READ_LENGTH, "b", NULL, 5, ASN1_MEM_ERROR},
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* Bug regression test: Empty write on 64-bit platforms */
- {ACT_CREATE,"TEST_TREE.Checksum",0,0,ASN1_SUCCESS},
- {ACT_WRITE,"checksum","foo",0,ASN1_SUCCESS},
- {ACT_WRITE,"checksum","",0,ASN1_SUCCESS},
- {ACT_ENCODING_LENGTH,"",0,4,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,3,ASN1_MEM_ERROR},
- {ACT_ENCODING,"",0,4,ASN1_SUCCESS},
- {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
- {ACT_CREATE,"TEST_TREE.Checksum",0,0,ASN1_SUCCESS},
- {ACT_DECODING,0,0,0,ASN1_SUCCESS},
- {ACT_DECODING_ELEMENT,"checksum",0,0,ASN1_SUCCESS},
- {ACT_READ,"checksum","",0,ASN1_SUCCESS},
- {ACT_READ_LENGTH,"checksum",NULL,0,ASN1_SUCCESS}, /* MEM_FAILURE? */
- {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
- {ACT_DELETE,"","",0,ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Checksum", 0, 0, ASN1_SUCCESS},
+ {ACT_WRITE, "checksum", "foo", 0, ASN1_SUCCESS},
+ {ACT_WRITE, "checksum", "", 0, ASN1_SUCCESS},
+ {ACT_ENCODING_LENGTH, "", 0, 4, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 3, ASN1_MEM_ERROR},
+ {ACT_ENCODING, "", 0, 4, ASN1_SUCCESS},
+ {ACT_PRINT_DER, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
+ {ACT_CREATE, "TEST_TREE.Checksum", 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING, 0, 0, 0, ASN1_SUCCESS},
+ {ACT_DECODING_ELEMENT, "checksum", 0, 0, ASN1_SUCCESS},
+ {ACT_READ, "checksum", "", 0, ASN1_SUCCESS},
+ {ACT_READ_LENGTH, "checksum", NULL, 0, ASN1_SUCCESS}, /* MEM_FAILURE? */
+ {ACT_VISIT, "", "", ASN1_PRINT_ALL, ASN1_SUCCESS},
+ {ACT_DELETE, "", "", 0, ASN1_SUCCESS},
/* end */
{ACT_NULL}
};
-int
-main(int argc,char *argv[])
+int
+main (int argc, char *argv[])
{
asn1_retCode result;
- ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
- ASN1_TYPE asn1_element=ASN1_TYPE_EMPTY;
+ ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
+ ASN1_TYPE asn1_element = ASN1_TYPE_EMPTY;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
FILE *out;
test_type *test;
- int errorCounter=0,testCounter=0,der_len;
- unsigned char value[1024],der[1024];
- int valueLen,tag=0,class=0;
+ int errorCounter = 0, testCounter = 0, der_len;
+ unsigned char value[1024], der[1024];
+ int valueLen, tag = 0, class = 0;
int k;
- int start,end;
- const char *str_p=NULL;
+ int start, end;
+ const char *str_p = NULL;
const char *treefile = getenv ("ASN1TREE");
if (!treefile)
treefile = "Test_tree.asn";
- printf("\n\n/****************************************/\n");
- printf( "/* Test sequence : Test_tree */\n");
- printf( "/****************************************/\n\n");
- printf("ASN1TREE: %s\n", treefile);
+ printf ("\n\n/****************************************/\n");
+ printf ("/* Test sequence : Test_tree */\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));
+ if (asn1_check_version ("0.2.11") == NULL)
+ printf ("\nLibrary version check ERROR:\n actual version: %s\n\n",
+ asn1_check_version (NULL));
- if(1)
- result=asn1_parser2tree(treefile,&definitions,errorDescription);
+ if (1)
+ result = asn1_parser2tree (treefile, &definitions, errorDescription);
else
- result=asn1_array2tree(Test_tree_asn1_tab,&definitions,errorDescription);
-
- if(result!=ASN1_SUCCESS){
- asn1_perror(result);
- printf("ErrorDescription = %s\n\n",errorDescription);
- exit(1);
- }
-
- if(1)
- out=stdout;
- else
- out=fopen("Test_tree.out","w");
-
- if(out==NULL){
- printf("Output file ERROR\n");
- exit(1);
- }
-
- if(0){
- asn1_print_structure(out,definitions,"TEST_TREE",ASN1_PRINT_ALL);
- fprintf(out,"\n");
- }
-
- test=test_array;
-
- while(test->action != ACT_NULL){
- testCounter++;
-
- switch(test->action){
- case ACT_CREATE:
- result=asn1_create_element(definitions,test->par1,&asn1_element);
- break;
- case ACT_DELETE:
- result=asn1_delete_structure(&asn1_element);
- break;
- case ACT_DELETE_ELEMENT:
- result=asn1_delete_element(asn1_element,test->par1);
- break;
- case ACT_WRITE:
- if((test->par2) && (!strcmp("DER",test->par2)))
- result=asn1_write_value(asn1_element,test->par1,der,der_len);
- else
- result=asn1_write_value(asn1_element,test->par1,test->par2,test->par3);
- break;
- case ACT_READ:
- case ACT_READ_BIT:
- valueLen=test->par3;
- result=asn1_read_value(asn1_element,test->par1,value,&valueLen);
- break;
- case ACT_READ_LENGTH:
- valueLen=0;
- result=asn1_read_value(asn1_element,test->par1,NULL,&valueLen);
- break;
- case ACT_READ_DEFINITIONS:
- valueLen=1024;
- result=asn1_read_value(definitions,test->par1,value,&valueLen);
- break;
- case ACT_READ_TAG_CLASS:
- result=asn1_read_tag(asn1_element,test->par1,&tag,&class);
- break;
- case ACT_ENCODING:
- der_len=test->par3;
- result=asn1_der_coding(asn1_element,test->par1,der,&der_len,
- errorDescription);
- break;
- case ACT_ENCODING_LENGTH:
- der_len=0;
- result=asn1_der_coding(asn1_element,test->par1,NULL,&der_len,
- errorDescription);
- break;
- case ACT_DECODING:
- result=asn1_der_decoding(&asn1_element,der,der_len,
- errorDescription);
- break;
- case ACT_DECODING_ELEMENT:
- result=asn1_der_decoding_element(&asn1_element,test->par1,der,der_len,
- errorDescription);
- break;
- case ACT_DECODING_START_END:
- result=asn1_der_decoding_startEnd(asn1_element,der,der_len,test->par1,
- &start,&end);
- break;
- case ACT_EXPAND_ANY:
- result=asn1_expand_any_defined_by(definitions,&asn1_element);
- break;
- case ACT_EXPAND_OCTET:
- result=asn1_expand_octet_string(definitions,&asn1_element,test->par1,
- test->par2);
- break;
- case ACT_OID_2_STRUCTURE:
- str_p=asn1_find_structure_from_oid(definitions,test->par1);
- break;
- case ACT_VISIT:
- asn1_print_structure(out,asn1_element,test->par1,test->par3);
- fprintf(out,"\n");
- result=ASN1_SUCCESS;
- break;
- case ACT_PRINT_DER:
- printf("DER encoding len:%i\n",der_len);
- printf("DER encoding: ");
- for(k=0;k<der_len;k++)
- printf("%02x ",der[k]);
- printf("\n\n");
- result=ASN1_SUCCESS;
- break;
- case ACT_SET_DER:
- der_len=test->par3;
- memcpy(der,test->par1,der_len);
- result=ASN1_SUCCESS;
- break;
- case ACT_NUMBER_OF_ELEMENTS:
- result=asn1_number_of_elements(asn1_element,test->par1,&valueLen);
- break;
- default:
- break;
+ result =
+ asn1_array2tree (Test_tree_asn1_tab, &definitions, errorDescription);
+
+ if (result != ASN1_SUCCESS)
+ {
+ asn1_perror (result);
+ printf ("ErrorDescription = %s\n\n", errorDescription);
+ exit (1);
}
+ if (1)
+ out = stdout;
+ else
+ out = fopen ("Test_tree.out", "w");
- switch(test->action){
- case ACT_CREATE:
- case ACT_DELETE:
- case ACT_DELETE_ELEMENT:
- case ACT_WRITE:
- case ACT_VISIT:
- case ACT_ENCODING:
- case ACT_DECODING:
- case ACT_PRINT_DER:
- case ACT_EXPAND_ANY:
- case ACT_EXPAND_OCTET:
- case ACT_SET_DER:
- if(result != test->errorNumber){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s - %s - %d\n",test->action,test->par1,
- test->par2,test->par3);
- printf(" Error expected: %s\n",asn1_strerror(test->errorNumber));
- printf(" Error detected: %s\n\n",asn1_strerror(result));
- }
- break;
- case ACT_DECODING_ELEMENT:
- if(result != test->errorNumber){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s - %s - %d\n",test->action,test->par1,
- test->par2,test->par3);
- printf(" Error expected: %s\n",asn1_strerror(test->errorNumber));
- printf(" Error detected: %s\n",asn1_strerror(result));
- printf(" Error description : %s\n\n",errorDescription);
- }
- break;
- case ACT_NUMBER_OF_ELEMENTS:
- case ACT_READ_LENGTH:
- if((result != test->errorNumber) ||
- (valueLen != test->par3)){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s\n",test->action,test->par1);
- printf(" Error expected: %s - %d\n",asn1_strerror(test->errorNumber),
- test->par3);
- printf(" Error detected: %s - %d\n\n",asn1_strerror(result),
- valueLen);
- }
- break;
- case ACT_ENCODING_LENGTH:
- if((result != test->errorNumber) ||
- (der_len != test->par3)){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s\n",test->action,test->par1);
- printf(" Error expected: %s - %d\n",asn1_strerror(test->errorNumber),
- test->par3);
- printf(" Error detected: %s - %d\n\n",asn1_strerror(result),
- der_len);
- }
- break;
- case ACT_OID_2_STRUCTURE:
- if(((test->errorNumber!=ASN1_SUCCESS) && (str_p!=NULL)) ||
- ((test->errorNumber==ASN1_SUCCESS) && (str_p==NULL)) ||
- ((test->errorNumber==ASN1_SUCCESS) && (strcmp(str_p,test->par2)))){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s\n",test->action,test->par1);
- printf(" Error expected: %s - %s\n",asn1_strerror(test->errorNumber),test->par2);
- printf(" Value detected: %s\n\n",str_p);
- }
- break;
- case ACT_DECODING_START_END:
- if((result != test->errorNumber) ||
- ((!strcmp(test->par2,"START")) && (start != test->par3)) ||
- ((!strcmp(test->par2,"END")) && (end != test->par3)) ){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s - %d\n",test->action,test->par1,
- test->par3);
- printf(" Error expected: %s - %s - %d\n",asn1_strerror(test->errorNumber),
- test->par2,test->par3);
- printf(" Error detected: %s - %d - %d\n\n",asn1_strerror(result),
- start,end);
- }
- break;
-
- case ACT_READ_TAG_CLASS:
- if((result != test->errorNumber) ||
- ((!strcmp(test->par2,"TAG")) && (tag != test->par3)) ||
- ((!strcmp(test->par2,"CLASS")) && (class != test->par3))){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s - %d\n",test->action,test->par1,
- test->par3);
- printf(" Error expected: %s - %s - %d\n",asn1_strerror(test->errorNumber),
- test->par2,test->par3);
- printf(" Error detected: %s - %d - %d\n\n",asn1_strerror(result),
- tag,class);
- }
-
- break;
-
- case ACT_READ:
- case ACT_READ_DEFINITIONS:
- case ACT_READ_BIT:
- if(test->action==ACT_READ_BIT){
- if((valueLen-(valueLen/8.0))==0) tag=valueLen/8;
- else tag=(valueLen/8)+1;
- if((test->par3-(test->par3/8.0))==0) class=test->par3/8;
- else class=(test->par3/8)+1;
- }
-
- for(k=0;k<class;k++)
- if(test->par2[k] != value[k]){
- k=-1;
- break;
- }
+ if (out == NULL)
+ {
+ printf ("Output file ERROR\n");
+ exit (1);
+ }
- if((result != test->errorNumber) ||
- (valueLen != test->par3) ||
- (k == -1)){
- errorCounter++;
- printf("ERROR N. %d:\n",errorCounter);
- printf(" Action %d - %s\n",test->action,test->par1);
- printf(" Error expected: %s - %d - ",asn1_strerror(test->errorNumber),
- test->par3);
- for(k=0;k<test->par3;k++)
- printf("%02x",test->par2[k]);
- printf("\n Error detected: %s - %d - ",asn1_strerror(result),
- valueLen);
- for(k=0;k<valueLen;k++)
- printf("%02x",value[k]);
- printf("\n\n");
-
- }
-
- break;
- default:
- break;
+ if (0)
+ {
+ asn1_print_structure (out, definitions, "TEST_TREE", ASN1_PRINT_ALL);
+ fprintf (out, "\n");
}
- test++;
- }
+ test = test_array;
+ while (test->action != ACT_NULL)
+ {
+ testCounter++;
- printf("Total tests : %d\n",testCounter);
- printf("Total errors: %d\n",errorCounter);
+ switch (test->action)
+ {
+ case ACT_CREATE:
+ result =
+ asn1_create_element (definitions, test->par1, &asn1_element);
+ break;
+ case ACT_DELETE:
+ result = asn1_delete_structure (&asn1_element);
+ break;
+ case ACT_DELETE_ELEMENT:
+ result = asn1_delete_element (asn1_element, test->par1);
+ break;
+ case ACT_WRITE:
+ if ((test->par2) && (!strcmp ("DER", test->par2)))
+ result =
+ asn1_write_value (asn1_element, test->par1, der, der_len);
+ else
+ result =
+ asn1_write_value (asn1_element, test->par1, test->par2,
+ test->par3);
+ break;
+ case ACT_READ:
+ case ACT_READ_BIT:
+ valueLen = test->par3;
+ result =
+ asn1_read_value (asn1_element, test->par1, value, &valueLen);
+ break;
+ case ACT_READ_LENGTH:
+ valueLen = 0;
+ result =
+ asn1_read_value (asn1_element, test->par1, NULL, &valueLen);
+ break;
+ case ACT_READ_DEFINITIONS:
+ valueLen = 1024;
+ result =
+ asn1_read_value (definitions, test->par1, value, &valueLen);
+ break;
+ case ACT_READ_TAG_CLASS:
+ result = asn1_read_tag (asn1_element, test->par1, &tag, &class);
+ break;
+ case ACT_ENCODING:
+ der_len = test->par3;
+ result = asn1_der_coding (asn1_element, test->par1, der, &der_len,
+ errorDescription);
+ break;
+ case ACT_ENCODING_LENGTH:
+ der_len = 0;
+ result = asn1_der_coding (asn1_element, test->par1, NULL, &der_len,
+ errorDescription);
+ break;
+ case ACT_DECODING:
+ result = asn1_der_decoding (&asn1_element, der, der_len,
+ errorDescription);
+ break;
+ case ACT_DECODING_ELEMENT:
+ result =
+ asn1_der_decoding_element (&asn1_element, test->par1, der,
+ der_len, errorDescription);
+ break;
+ case ACT_DECODING_START_END:
+ result =
+ asn1_der_decoding_startEnd (asn1_element, der, der_len,
+ test->par1, &start, &end);
+ break;
+ case ACT_EXPAND_ANY:
+ result = asn1_expand_any_defined_by (definitions, &asn1_element);
+ break;
+ case ACT_EXPAND_OCTET:
+ result =
+ asn1_expand_octet_string (definitions, &asn1_element, test->par1,
+ test->par2);
+ break;
+ case ACT_OID_2_STRUCTURE:
+ str_p = asn1_find_structure_from_oid (definitions, test->par1);
+ break;
+ case ACT_VISIT:
+ asn1_print_structure (out, asn1_element, test->par1, test->par3);
+ fprintf (out, "\n");
+ result = ASN1_SUCCESS;
+ break;
+ case ACT_PRINT_DER:
+ printf ("DER encoding len:%i\n", der_len);
+ printf ("DER encoding: ");
+ for (k = 0; k < der_len; k++)
+ printf ("%02x ", der[k]);
+ printf ("\n\n");
+ result = ASN1_SUCCESS;
+ break;
+ case ACT_SET_DER:
+ der_len = test->par3;
+ memcpy (der, test->par1, der_len);
+ result = ASN1_SUCCESS;
+ break;
+ case ACT_NUMBER_OF_ELEMENTS:
+ result =
+ asn1_number_of_elements (asn1_element, test->par1, &valueLen);
+ break;
+ default:
+ break;
+ }
- /* Clear the definition structures */
- asn1_delete_structure(&definitions);
+ switch (test->action)
+ {
+ case ACT_CREATE:
+ case ACT_DELETE:
+ case ACT_DELETE_ELEMENT:
+ case ACT_WRITE:
+ case ACT_VISIT:
+ case ACT_ENCODING:
+ case ACT_DECODING:
+ case ACT_PRINT_DER:
+ case ACT_EXPAND_ANY:
+ case ACT_EXPAND_OCTET:
+ case ACT_SET_DER:
+ if (result != test->errorNumber)
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s - %s - %d\n", test->action,
+ test->par1, test->par2, test->par3);
+ printf (" Error expected: %s\n",
+ asn1_strerror (test->errorNumber));
+ printf (" Error detected: %s\n\n", asn1_strerror (result));
+ }
+ break;
+ case ACT_DECODING_ELEMENT:
+ if (result != test->errorNumber)
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s - %s - %d\n", test->action,
+ test->par1, test->par2, test->par3);
+ printf (" Error expected: %s\n",
+ asn1_strerror (test->errorNumber));
+ printf (" Error detected: %s\n", asn1_strerror (result));
+ printf (" Error description : %s\n\n", errorDescription);
+ }
+ break;
+ case ACT_NUMBER_OF_ELEMENTS:
+ case ACT_READ_LENGTH:
+ if ((result != test->errorNumber) || (valueLen != test->par3))
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s\n", test->action, test->par1);
+ printf (" Error expected: %s - %d\n",
+ asn1_strerror (test->errorNumber), test->par3);
+ printf (" Error detected: %s - %d\n\n", asn1_strerror (result),
+ valueLen);
+ }
+ break;
+ case ACT_ENCODING_LENGTH:
+ if ((result != test->errorNumber) || (der_len != test->par3))
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s\n", test->action, test->par1);
+ printf (" Error expected: %s - %d\n",
+ asn1_strerror (test->errorNumber), test->par3);
+ printf (" Error detected: %s - %d\n\n", asn1_strerror (result),
+ der_len);
+ }
+ break;
+ case ACT_OID_2_STRUCTURE:
+ if (((test->errorNumber != ASN1_SUCCESS) && (str_p != NULL)) ||
+ ((test->errorNumber == ASN1_SUCCESS) && (str_p == NULL)) ||
+ ((test->errorNumber == ASN1_SUCCESS)
+ && (strcmp (str_p, test->par2))))
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s\n", test->action, test->par1);
+ printf (" Error expected: %s - %s\n",
+ asn1_strerror (test->errorNumber), test->par2);
+ printf (" Value detected: %s\n\n", str_p);
+ }
+ break;
+ case ACT_DECODING_START_END:
+ if ((result != test->errorNumber) ||
+ ((!strcmp (test->par2, "START")) && (start != test->par3)) ||
+ ((!strcmp (test->par2, "END")) && (end != test->par3)))
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s - %d\n", test->action, test->par1,
+ test->par3);
+ printf (" Error expected: %s - %s - %d\n",
+ asn1_strerror (test->errorNumber), test->par2,
+ test->par3);
+ printf (" Error detected: %s - %d - %d\n\n",
+ asn1_strerror (result), start, end);
+ }
+ break;
+ case ACT_READ_TAG_CLASS:
+ if ((result != test->errorNumber) ||
+ ((!strcmp (test->par2, "TAG")) && (tag != test->par3)) ||
+ ((!strcmp (test->par2, "CLASS")) && (class != test->par3)))
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s - %d\n", test->action, test->par1,
+ test->par3);
+ printf (" Error expected: %s - %s - %d\n",
+ asn1_strerror (test->errorNumber), test->par2,
+ test->par3);
+ printf (" Error detected: %s - %d - %d\n\n",
+ asn1_strerror (result), tag, class);
+ }
- if(out != stdout) fclose(out);
+ break;
- if(errorCounter > 0)
- return 1;
+ case ACT_READ:
+ case ACT_READ_DEFINITIONS:
+ case ACT_READ_BIT:
+ if (test->action == ACT_READ_BIT)
+ {
+ if ((valueLen - (valueLen / 8.0)) == 0)
+ tag = valueLen / 8;
+ else
+ tag = (valueLen / 8) + 1;
+ if ((test->par3 - (test->par3 / 8.0)) == 0)
+ class = test->par3 / 8;
+ else
+ class = (test->par3 / 8) + 1;
+ }
+
+ for (k = 0; k < class; k++)
+ if (test->par2[k] != value[k])
+ {
+ k = -1;
+ break;
+ }
+
+ if ((result != test->errorNumber) ||
+ (valueLen != test->par3) || (k == -1))
+ {
+ errorCounter++;
+ printf ("ERROR N. %d:\n", errorCounter);
+ printf (" Action %d - %s\n", test->action, test->par1);
+ printf (" Error expected: %s - %d - ",
+ asn1_strerror (test->errorNumber), test->par3);
+ for (k = 0; k < test->par3; k++)
+ printf ("%02x", test->par2[k]);
+ printf ("\n Error detected: %s - %d - ",
+ asn1_strerror (result), valueLen);
+ for (k = 0; k < valueLen; k++)
+ printf ("%02x", value[k]);
+ printf ("\n\n");
+
+ }
- exit(0);
-}
+ break;
+ default:
+ break;
+ }
+ test++;
+ }
+ printf ("Total tests : %d\n", testCounter);
+ printf ("Total errors: %d\n", errorCounter);
+ /* Clear the definition structures */
+ asn1_delete_structure (&definitions);
+ if (out != stdout)
+ fclose (out);
+ if (errorCounter > 0)
+ return 1;
+ exit (0);
+}
-#define HAVE_GETOPT_H 1
\ No newline at end of file
+#define HAVE_GETOPT_H 1
#define HAVE_GETOPT_LONG 1\r
-#include "getopt_.h"
\ No newline at end of file
+#include "getopt_.h"
projects / platform / upstream / libtasn1.git / commitdiff