FCL/sf/os/xmlsrv: comparison xmlsecurityengine/xmlseccrypto/src/xmlsecc

equal deleted inserted replaced

-:e724ec518437
+:9b1f1fe06753
 /* reserved for the future */
 NULL,					/* void* reserved0; */
 NULL,					/* void* reserved1; */
 };
-static int		xmlSecSymbianCryptoX509VerifyCrl			(X509_STORE* xst,
+/*static int		xmlSecSymbianCryptoX509VerifyCrl			(X509_STORE* xst,
-									 X509_CRL *crl );
+									 X509_CRL *crl );*/
 static X509*		xmlSecSymbianCryptoX509FindCert			(STACK_OF(X509) *certs,
 									 xmlChar *subjectName,
 									 xmlChar *issuerName,
 									 xmlChar *issuerSerial,
 									 xmlChar *ski);
-static X509*		xmlSecSymbianCryptoX509FindNextChainCert		(STACK_OF(X509) *chain,
+/*static X509*		xmlSecSymbianCryptoX509FindNextChainCert		(STACK_OF(X509) *chain,
 		    							 X509 *cert);
 static int		xmlSecSymbianCryptoX509VerifyCertAgainstCrls		(STACK_OF(X509_CRL) *crls,
 								         X509* cert);
 static X509_NAME*	xmlSecSymbianCryptoX509NameRead			(xmlSecByte *str,
 									 int len);
 									 int ingoreTrailingSpaces);
 static int		xmlSecSymbianCryptoX509NamesCompare			(X509_NAME *a,
 									 X509_NAME *b);
 static int 		xmlSecSymbianCryptoX509_NAME_cmp			(const X509_NAME *a,
 									 const X509_NAME *b);
-/*
 static int 		xmlSecSymbianCryptoX509_NAME_ENTRY_cmp		(const X509_NAME_ENTRY **a,
 									 const X509_NAME_ENTRY **b);
 */
 /**
 * xmlSecSymbianCryptoX509StoreGetKlass:
 */
 EXPORT_C
 int
 xmlSecSymbianCryptoX509StoreKeyCertVerify(xmlSecKeyDataStorePtr store, X509* cert) {
 xmlSecSymbianCryptoX509StoreCtxPtr ctx;
-X509* res = NULL;
-X509 *err_cert = NULL;
-char buf[256];
-int err = 0, depth;
+int err = 0;
-int i;
-int ret;
 xmlSecAssert2(xmlSecKeyDataStoreCheckId(store, xmlSecSymbianCryptoX509StoreId), NULL);
 xmlSecAssert2(cert, NULL);
 ctx = xmlSecSymbianCryptoX509StoreGetCtx(store);
 EXPORT_C
 X509*
 xmlSecSymbianCryptoX509StoreVerify(xmlSecKeyDataStorePtr store, XMLSEC_STACK_OF_X509* certs,
 			     XMLSEC_STACK_OF_X509_CRL* crls, xmlSecKeyInfoCtx* keyInfoCtx) {
 xmlSecSymbianCryptoX509StoreCtxPtr ctx;
-STACK_OF(X509)* certs2 = NULL;
 X509* res = NULL;
 X509* cert = NULL;
-X509 *err_cert = NULL;
-char buf[256];
-int err = 0, depth;
+int err = 0;
-int i;
 int ret;
 xmlSecAssert2(xmlSecKeyDataStoreCheckId(store, xmlSecSymbianCryptoX509StoreId), NULL);
 xmlSecAssert2(certs, NULL);
 xmlSecAssert2(keyInfoCtx, NULL);
 return(0);
 }
 static int
 xmlSecSymbianCryptoX509StoreInitialize(xmlSecKeyDataStorePtr store) {
-const xmlChar* path;
 xmlSecSymbianCryptoX509StoreCtxPtr ctx;
 xmlSecAssert2(xmlSecKeyDataStoreCheckId(store, xmlSecSymbianCryptoX509StoreId), -1);
 ctx = xmlSecSymbianCryptoX509StoreGetCtx(store);
 /*****************************************************************************
 *
 * Low-level x509 functions
 *
 *****************************************************************************/
-static int
+/*static int
 xmlSecSymbianCryptoX509VerifyCrl(X509_STORE* xst, X509_CRL *crl ) {
 EVP_PKEY *pkey;
 int ret = 0;
 #ifdef XMLSEC_FUTURE_SUPPORT
 }
 X509_STORE_CTX_cleanup (&xsc);
 #endif		//XMLSEC_FUTURE_SUPPORT
 return((ret == 1) ? 1 : 0);
 }
+*/
 /**
 * xmlSecSymbianCryptoX509FindCert:
 */
 static X509*
 xmlSecSymbianCryptoX509FindCert(STACK_OF(X509) *certs, xmlChar *subjectName,
 			xmlChar *issuerName, xmlChar *issuerSerial,
 			xmlChar *ski) {
-X509 *cert = NULL;
-int i;
 xmlSecAssert2(certs, NULL);
 #ifdef XMLSEC_FUTURE_SUPPORT
 /* may be this is not the fastest way to search certs */
 if(subjectName) {
 }
 /**
 * xmlSecSymbianCryptoX509FindNextChainCert:
 */
+/*
 static X509*
 xmlSecSymbianCryptoX509FindNextChainCert(STACK_OF(X509) *chain, X509 *cert) {
-unsigned long certSubjHash;
-int i;
 xmlSecAssert2(chain, NULL);
 xmlSecAssert2(cert, NULL);
-/*
 certSubjHash = X509_subject_name_hash(cert);
 for(i = 0; i < sk_X509_num(chain); ++i) {
 	if((sk_X509_value(chain, i) != cert) &&
 	   (X509_issuer_name_hash(sk_X509_value(chain, i)) == certSubjHash)) {
 	    return(sk_X509_value(chain, i));
 	}
 }
-*/
 return(NULL);
 }
+*/
 /**
 * xmlSecSymbianCryptoX509VerifyCertAgainstCrls:
 */
+/*
 static int
 xmlSecSymbianCryptoX509VerifyCertAgainstCrls(STACK_OF(X509_CRL) *crls, X509* cert) {
-X509_NAME *issuer;
-X509_CRL *crl = NULL;
 #ifdef XMLSEC_FUTURE_SUPPORT
 X509_REVOKED *revoked;
 int i, n;
 int ret;
 xmlSecAssert2(crls, -1);
 xmlSecAssert2(cert, -1);
-/*
 * Try to retrieve a CRL corresponding to the issuer of
 * the current certificate
-*/
 n = sk_X509_CRL_num(crls);
 for(i = 0; i < n; i++) {
 	crl = sk_X509_CRL_value(crls, i);
 	issuer = X509_CRL_get_issuer(crl);
 	if(xmlSecSymbianCryptoX509NamesCompare(X509_CRL_get_issuer(crl), issuer) == 0) {
 	    break;
 	}
 }
 if((i >= n) || (!crl)){
-	/* no crls for this issuer */
+	// no crls for this issuer
 	return(1);
 }
-/*
-* Check date of CRL to make sure it's not expired
+// Check date of CRL to make sure it's not expired
-*/
 ret = X509_cmp_current_time(X509_CRL_get_nextUpdate(crl));
 if (ret == 0) {
-	/* crl expired */
+	//crl expired
 	return(1);
 }
-/*
-* Check if the current certificate is revoked by this CRL
+// Check if the current certificate is revoked by this CRL
-*/
 n = sk_num(X509_CRL_get_REVOKED(crl));
 for (i = 0; i < n; i++) {
 revoked = (X509_REVOKED *)sk_value(X509_CRL_get_REVOKED(crl), i);
 if (ASN1_INTEGER_cmp(revoked->serialNumber, X509_get_serialNumber(cert)) == 0) {
 	    xmlSecError(XMLSEC_ERRORS_HERE,
 }
 }
 #endif		//XMLSEC_FUTURE_SUPPORT
 return(1);
 }
+*/
 /**
 * xmlSecSymbianCryptoX509NameRead:
 */
+/*
 static X509_NAME *
 xmlSecSymbianCryptoX509NameRead(xmlSecByte *str, int len) {
-xmlSecByte name[256];
-xmlSecByte value[256];
-int nameLen, valueLen;
 X509_NAME *nm = NULL;
 xmlSecAssert2(str, NULL);
 #ifdef XMLSEC_FUTURE_SUPPORT
 		    XMLSEC_ERRORS_NO_MESSAGE);
 	return(NULL);
 }
 while(len > 0) {
-	/* skip spaces after comma or semicolon */
+	//skip spaces after comma or semicolon
 	while((len > 0) && isspace(*str)) {
 	    ++str; --len;
 	}
 	nameLen = xmlSecSymbianCryptoX509NameStringRead(&str, &len, name, sizeof(name), '=', 0);
 				XMLSEC_ERRORS_NO_MESSAGE);
 		    X509_NAME_free(nm);
 		    return(NULL);
 		}
-		/* skip quote */
+		//skip quote
 		if((len <= 0) || ((*str) != '\"')) {
 		    xmlSecError(XMLSEC_ERRORS_HERE,
 				NULL,
 				NULL,
 				XMLSEC_ERRORS_R_INVALID_DATA,
 		    X509_NAME_free(nm);
 		    return(NULL);
 		}
 ++str; --len;
-		/* skip spaces before comma or semicolon */
+		//skip spaces before comma or semicolon
 		while((len > 0) && isspace(*str)) {
 		    ++str; --len;
 		}
 		if((len > 0) && ((*str) != ',')) {
 		    xmlSecError(XMLSEC_ERRORS_HERE,
 		if(len > 0) {
 		    ++str; --len;
 		}
 		type = MBSTRING_ASC;
 	    } else if((*str) == '#') {
-		/* Not implemented currently */
+		//Not implemented currently
 		xmlSecError(XMLSEC_ERRORS_HERE,
 			    NULL,
 			    NULL,
 			    XMLSEC_ERRORS_R_INVALID_DATA,
 			    "reading octect values is not implemented yet");
 }
 #endif	//XMLSEC_FUTURE_SUPPORT
 return(nm);
 }
+*/
 /**
 * xmlSecSymbianCryptoX509NameStringRead:
 */
+/*
 static int
 xmlSecSymbianCryptoX509NameStringRead(xmlSecByte **str, int *strLen,
 			xmlSecByte *res, int resLen,
 			xmlSecByte delim, int ingoreTrailingSpaces) {
 xmlSecByte *p, *q, *nonSpace;
 }
 (*strLen) -= (p - (*str));
 (*str) = p;
 return((ingoreTrailingSpaces) ? nonSpace - res + 1 : q - res);
 }
+*/
+/*
 static
 int xmlSecSymbianCryptoX509_NAME_cmp(const X509_NAME *a, const X509_NAME *b) {
-int i,ret;
-/*
 const X509_NAME_ENTRY *na,*nb;
 xmlSecAssert2(a != NULL, -1);
 xmlSecAssert2(b != NULL, 1);
 	ret = xmlSecSymbianCryptoX509_NAME_ENTRY_cmp(&na, &nb);
 	if(ret != 0) {
 	    return(ret);
 	}
 }
+return(0);
+}
 */
-return(0);
-}
 /**
 * xmlSecSymbianCryptoX509NamesCompare:
 *
 * we have to sort X509_NAME entries to get correct results.
 * This is ugly but SymbianCrypto does not support it
 */
+/*
 static int
 xmlSecSymbianCryptoX509NamesCompare(X509_NAME *a, X509_NAME *b) {
 X509_NAME *a1 = NULL;
 X509_NAME *b1 = NULL;
 int ret = -1;
 		    XMLSEC_ERRORS_R_CRYPTO_FAILED,
 		    XMLSEC_ERRORS_NO_MESSAGE);
 return(1);
 }
-/* sort both */
+//sort both
 sk_X509_NAME_ENTRY_set_cmp_func(a1->entries, xmlSecSymbianCryptoX509_NAME_ENTRY_cmp);
 sk_X509_NAME_ENTRY_sort(a1->entries);
 sk_X509_NAME_ENTRY_set_cmp_func(b1->entries, xmlSecSymbianCryptoX509_NAME_ENTRY_cmp);
 sk_X509_NAME_ENTRY_sort(b1->entries);
-/* actually compare */
+//actually compare
 ret = xmlSecSymbianCryptoX509_NAME_cmp(a1, b1);
-/* cleanup */
+//cleanup
 X509_NAME_free(a1);
 X509_NAME_free(b1);
 #endif		//XMLSEC_FUTURE_SUPPORT
 return(ret);
 }
+		*/
 /**
 * xmlSecSymbianCryptoX509_NAME_ENTRY_cmp:
 */
 #ifdef XMLSEC_FUTURE_SUPPORT

changeset 15	9b1f1fe06753
parent 0	e35f40988205
child 24	74f0b3eb154c