separated buffer klass

18 files changed, 626 insertions, 467 deletions

diff --git a/include/xmlsec/Makefile.am b/include/xmlsec/Makefile.am
index 3d7fc73e..7f5e9e40 100644
--- a/include/xmlsec/Makefile.am
+++ b/include/xmlsec/Makefile.am
@@ -6,6 +6,7 @@ xmlsecincdir = $(includedir)/xmlsec
 
 xmlsecinc_HEADERS = \
 base64.h \
+buffer.h \
 debug.h \
 errors.h \
 io.h \
diff --git a/include/xmlsec/buffer.h b/include/xmlsec/buffer.h
new file mode 100644
index 00000000..2b84c0ea
--- /dev/null
+++ b/include/xmlsec/buffer.h
@@ -0,0 +1,77 @@
+/** 
+ * XMLSec library
+ *
+ * Memory buffer
+ *
+ * See Copyright for the status of this software.
+ * 
+ * Author: Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_BUFFER_H__
+#define __XMLSEC_BUFFER_H__    
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */ 
+
+#include <libxml/tree.h>
+#include <xmlsec/xmlsec.h>
+
+typedef struct _xmlSecBuffer				xmlSecBuffer, *xmlSecBufferPtr;
+
+enum xmlSecAllocMode{
+    xmlSecAllocExact = 0,
+    xmlSecAllocDouble
+};
+
+/*****************************************************************************
+ *
+ * xmlSecBuffer
+ *
+ ****************************************************************************/
+struct _xmlSecBuffer {
+    unsigned char* 	 data;
+    size_t 		 size;
+    size_t		 maxSize;
+    enum xmlSecAllocMode allocMode;
+};
+
+XMLSEC_EXPORT xmlSecBufferPtr	xmlSecBufferCreate		(size_t size);
+XMLSEC_EXPORT void		xmlSecBufferDestroy		(xmlSecBufferPtr buf);
+XMLSEC_EXPORT int		xmlSecBufferInitialize		(xmlSecBufferPtr buf,
+								 size_t size);
+XMLSEC_EXPORT void		xmlSecBufferFinalize		(xmlSecBufferPtr buf);
+XMLSEC_EXPORT unsigned char*	xmlSecBufferGetData		(xmlSecBufferPtr buf);
+XMLSEC_EXPORT int		xmlSecBufferSetData		(xmlSecBufferPtr buf,
+								 const unsigned char* data,
+								 size_t size);
+XMLSEC_EXPORT size_t		xmlSecBufferGetSize		(xmlSecBufferPtr buf);
+XMLSEC_EXPORT int		xmlSecBufferSetSize		(xmlSecBufferPtr buf,
+								 size_t size);
+XMLSEC_EXPORT size_t		xmlSecBufferGetMaxSize		(xmlSecBufferPtr buf);
+XMLSEC_EXPORT int		xmlSecBufferSetMaxSize		(xmlSecBufferPtr buf,
+								 size_t size);
+XMLSEC_EXPORT void		xmlSecBufferEmpty		(xmlSecBufferPtr buf);
+XMLSEC_EXPORT int		xmlSecBufferAppend		(xmlSecBufferPtr buf,
+								 const unsigned char* data,
+								 size_t size);
+XMLSEC_EXPORT int		xmlSecBufferPrepend		(xmlSecBufferPtr buf,
+								 const unsigned char* data,
+								 size_t size);
+XMLSEC_EXPORT int		xmlSecBufferRemoveHead		(xmlSecBufferPtr buf,
+								 size_t size);
+XMLSEC_EXPORT int		xmlSecBufferRemoveTail		(xmlSecBufferPtr buf,
+								 size_t size);
+
+XMLSEC_EXPORT int		xmlSecBufferBase64NodeContentRead(xmlSecBufferPtr buf,
+								 xmlNodePtr node);
+XMLSEC_EXPORT int		xmlSecBufferBase64NodeContentWrite(xmlSecBufferPtr buf,
+								 xmlNodePtr node,
+								 int columns);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __XMLSEC_BUFFER_H__ */
+
diff --git a/include/xmlsec/keys.h b/include/xmlsec/keys.h
index 21166198..efd43900 100644
--- a/include/xmlsec/keys.h
+++ b/include/xmlsec/keys.h
@@ -19,6 +19,46 @@ extern "C" {
 #include <xmlsec/list.h>
 #include <xmlsec/keysdata.h>
 
+
+/**
+ * xmlSecKeyUsage:
+ * @xmlSecKeyUsageAny: the key can be used in any way.
+ * @xmlSecKeyUsageSign: the key for signing.
+ * @xmlSecKeyUsageVerify: the key for signature verification.
+ * @xmlSecKeyUsageEncrypt: the encryption key.
+ * @xmlSecKeyUsageDecrypt: the decryption key.
+ *
+ * The key usage.
+ */
+typedef enum  {
+    xmlSecKeyUsageAny = 0,
+    xmlSecKeyUsageSign,
+    xmlSecKeyUsageVerify,
+    xmlSecKeyUsageEncrypt,
+    xmlSecKeyUsageDecrypt
+} xmlSecKeyUsage;
+
+
+/**************************************************************************
+ *
+ * xmlSecKeyReq - what key are we looking for?
+ *
+ *************************************************************************/
+typedef struct _xmlSecKeyReq 			xmlSecKeyReq, *xmlSecKeyReqPtr; 
+struct _xmlSecKeyReq {
+    xmlSecKeyDataId			keyId;
+    xmlSecKeyDataType			keyType;
+    xmlSecKeyUsage			keyUsage;
+    size_t				keyBitsSize;
+};
+
+XMLSEC_EXPORT int	xmlSecKeyReqInitialize			(xmlSecKeyReqPtr keyReq);
+XMLSEC_EXPORT void	xmlSecKeyReqFinalize			(xmlSecKeyReqPtr keyReq);
+XMLSEC_EXPORT int	xmlSecKeyReqCopy			(xmlSecKeyReqPtr dst,
+								 xmlSecKeyReqPtr src);
+XMLSEC_EXPORT int	xmlSecKeyReqValidate			(xmlSecKeyReqPtr keyReq,
+								 xmlSecKeyPtr key);
+
 /**
  * xmlSecKeyInifiteRetrivals:
  *
@@ -48,24 +88,6 @@ extern "C" {
  	(xmlSecKeyIsValid(( key )) && \
 	((( key )->value->id) == ( keyId )))
 
-/**
- * xmlSecKeyUsage:
- * @xmlSecKeyUsageAny: the key can be used in any way.
- * @xmlSecKeyUsageSign: the key for signing.
- * @xmlSecKeyUsageVerify: the key for signature verification.
- * @xmlSecKeyUsageEncrypt: the encryption key.
- * @xmlSecKeyUsageDecrypt: the decryption key.
- *
- * The key usage.
- */
-typedef enum  {
-    xmlSecKeyUsageAny = 0,
-    xmlSecKeyUsageSign,
-    xmlSecKeyUsageVerify,
-    xmlSecKeyUsageEncrypt,
-    xmlSecKeyUsageDecrypt
-} xmlSecKeyUsage;
-
 /** 
  * xmlSecKeyOrigin:
  * 
diff --git a/include/xmlsec/keysdata.h b/include/xmlsec/keysdata.h
index b76f631e..09e1fde7 100644
--- a/include/xmlsec/keysdata.h
+++ b/include/xmlsec/keysdata.h
@@ -15,7 +15,7 @@ extern "C" {
 #include <libxml/tree.h>
 
 #include <xmlsec/xmlsec.h>
-#include <xmlsec/membuf.h>
+#include <xmlsec/buffer.h>
 
 /**
  * Forward declarations
diff --git a/include/xmlsec/membuf.h b/include/xmlsec/membuf.h
index a6ecbe95..37c73507 100644
--- a/include/xmlsec/membuf.h
+++ b/include/xmlsec/membuf.h
@@ -17,57 +17,24 @@ extern "C" {
 #include <libxml/tree.h>
 
 #include <xmlsec/xmlsec.h>
-typedef struct _xmlSecBuffer				xmlSecBuffer, *xmlSecBufferPtr;
+#include <xmlsec/buffer.h>
 
-enum xmlSecAllocMode{
-    xmlSecAllocExact = 0,
-    xmlSecAllocDouble
-};
-
-/*****************************************************************************
+/********************************************************************
  *
- * xmlSecBuffer
+ * Memory Buffer transform 
  *
- ****************************************************************************/
-struct _xmlSecBuffer {
-    unsigned char* 	 data;
-    size_t 		 size;
-    size_t		 maxSize;
-    enum xmlSecAllocMode allocMode;
-};
-
-XMLSEC_EXPORT xmlSecBufferPtr	xmlSecBufferCreate		(size_t size);
-XMLSEC_EXPORT void		xmlSecBufferDestroy		(xmlSecBufferPtr buf);
-XMLSEC_EXPORT int		xmlSecBufferInitialize		(xmlSecBufferPtr buf,
-								 size_t size);
-XMLSEC_EXPORT void		xmlSecBufferFinalize		(xmlSecBufferPtr buf);
-XMLSEC_EXPORT unsigned char*	xmlSecBufferGetData		(xmlSecBufferPtr buf);
-XMLSEC_EXPORT int		xmlSecBufferSetData		(xmlSecBufferPtr buf,
-								 const unsigned char* data,
-								 size_t size);
-XMLSEC_EXPORT size_t		xmlSecBufferGetSize		(xmlSecBufferPtr buf);
-XMLSEC_EXPORT int		xmlSecBufferSetSize		(xmlSecBufferPtr buf,
-								 size_t size);
-XMLSEC_EXPORT size_t		xmlSecBufferGetMaxSize		(xmlSecBufferPtr buf);
-XMLSEC_EXPORT int		xmlSecBufferSetMaxSize		(xmlSecBufferPtr buf,
-								 size_t size);
-XMLSEC_EXPORT void		xmlSecBufferEmpty		(xmlSecBufferPtr buf);
-XMLSEC_EXPORT int		xmlSecBufferAppend		(xmlSecBufferPtr buf,
-								 const unsigned char* data,
-								 size_t size);
-XMLSEC_EXPORT int		xmlSecBufferPrepend		(xmlSecBufferPtr buf,
-								 const unsigned char* data,
-								 size_t size);
-XMLSEC_EXPORT int		xmlSecBufferRemoveHead		(xmlSecBufferPtr buf,
-								 size_t size);
-XMLSEC_EXPORT int		xmlSecBufferRemoveTail		(xmlSecBufferPtr buf,
-								 size_t size);
+ *******************************************************************/
+/**
+ * xmlSecTransformMemBufId:
+ * 
+ * The Memory Buffer transform id.
+ */
+#define xmlSecTransformMemBufId \
+	xmlSecTransformMemBufGetKlass()
+XMLSEC_EXPORT xmlSecTransformId	xmlSecTransformMemBufGetKlass		(void);
+XMLSEC_EXPORT xmlSecBufferPtr	xmlSecTransformMemBufGetBuffer		(xmlSecTransformPtr transform, 
+									 int removeBuffer);
 
-XMLSEC_EXPORT int		xmlSecBufferBase64NodeContentRead(xmlSecBufferPtr buf,
-								 xmlNodePtr node);
-XMLSEC_EXPORT int		xmlSecBufferBase64NodeContentWrite(xmlSecBufferPtr buf,
-								 xmlNodePtr node,
-								 int columns);
 
 #ifdef __cplusplus
 }
diff --git a/include/xmlsec/transforms.h b/include/xmlsec/transforms.h
index 04243669..e07f2fd0 100644
--- a/include/xmlsec/transforms.h
+++ b/include/xmlsec/transforms.h
@@ -541,22 +541,6 @@ XMLSEC_EXPORT     void xmlSecTransformBase64SetLineSize			(xmlSecTransformPtr tr
 
 /********************************************************************
  *
- * Memory Buffer transform 
- *
- *******************************************************************/
-/**
- * xmlSecTransformMemBufId:
- * 
- * The Memory Buffer transform id.
- */
-#define xmlSecTransformMemBufId \
-	xmlSecTransformMemBufGetKlass()
-XMLSEC_EXPORT xmlSecTransformId	xmlSecTransformMemBufGetKlass		(void);
-XMLSEC_EXPORT xmlSecBufferPtr	xmlSecTransformMemBufGetBuffer		(xmlSecTransformPtr transform, 
-									 int removeBuffer);
-
-/********************************************************************
- *
  * Input URI transform 
  *
  *******************************************************************/
diff --git a/src/Makefile.am b/src/Makefile.am
index b14e2339..857252ca 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -17,6 +17,7 @@ lib_LTLIBRARIES = libxmlsec.la
 
 libxmlsec_la_SOURCES =\
 base64.c \
+buffer.c \
 c14n.c \
 debug.c \
 enveloped.c \
diff --git a/src/buffer.c b/src/buffer.c
new file mode 100644
index 00000000..0ff251e5
--- /dev/null
+++ b/src/buffer.c
@@ -0,0 +1,384 @@
+/** 
+ * XMLSec library
+ *
+ * Memory buffer transform
+ *
+ * See Copyright for the status of this software.
+ * 
+ * Author: Aleksey Sanin <aleksey@aleksey.com>
+ */
+#include "globals.h"
+
+#include <stdlib.h>
+#include <string.h>
+ 
+#include <libxml/tree.h>
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/base64.h>
+#include <xmlsec/buffer.h>
+#include <xmlsec/errors.h>
+
+/*****************************************************************************
+ *
+ * xmlSecBuffer
+ *
+ ****************************************************************************/
+xmlSecBufferPtr 
+xmlSecBufferCreate(size_t size) {
+    xmlSecBufferPtr buf;
+    int ret;
+    
+    buf = (xmlSecBufferPtr)xmlMalloc(sizeof(xmlSecBuffer));
+    if(buf == NULL) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlMalloc",
+		    XMLSEC_ERRORS_R_MALLOC_FAILED,
+		    "sizeof(xmlSecBuffer)=%d", sizeof(xmlSecBuffer));
+	return(NULL);
+    }
+
+    ret = xmlSecBufferInitialize(buf, size);
+    if(ret < 0) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlSecBufferInitialize",
+		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+		    "size=%d", size);
+	xmlSecBufferDestroy(buf);
+	return(NULL);
+    }
+    
+    return(buf);
+}
+
+void 
+xmlSecBufferDestroy(xmlSecBufferPtr buf) {
+    xmlSecAssert(buf != NULL);
+    
+    xmlSecBufferFinalize(buf);
+    xmlFree(buf);
+}
+
+int 
+xmlSecBufferInitialize(xmlSecBufferPtr buf, size_t size) {
+    xmlSecAssert2(buf != NULL, -1);
+
+    buf->data = NULL;
+    buf->size = buf->maxSize = 0;
+    buf->allocMode = xmlSecAllocExact;
+        
+    return(xmlSecBufferSetMaxSize(buf, size));
+}
+
+void 
+xmlSecBufferFinalize(xmlSecBufferPtr buf) {
+    xmlSecAssert(buf != NULL);
+
+    xmlSecBufferEmpty(buf);    
+    if(buf->data != 0) {
+	xmlFree(buf->data);
+    }
+    buf->data = NULL;
+    buf->size = buf->maxSize = 0;
+}
+
+void
+xmlSecBufferEmpty(xmlSecBufferPtr buf) {
+    xmlSecAssert(buf != NULL);
+    
+    if(buf->data != 0) {
+	xmlSecAssert(buf->maxSize > 0);
+
+	memset(buf->data, 0, buf->maxSize);
+    }
+    buf->size = 0;
+}
+
+unsigned char* 
+xmlSecBufferGetData(xmlSecBufferPtr buf) {
+    xmlSecAssert2(buf != NULL, NULL);
+    
+    return(buf->data);
+}
+
+int 
+xmlSecBufferSetData(xmlSecBufferPtr buf, const unsigned char* data, size_t size) {
+    int ret;
+    
+    xmlSecAssert2(buf != NULL, -1);
+
+    xmlSecBufferEmpty(buf);
+    if(size > 0) {
+	xmlSecAssert2(data != NULL, -1);
+    
+	ret = xmlSecBufferSetMaxSize(buf, size);
+	if(ret < 0) {
+	    xmlSecError(XMLSEC_ERRORS_HERE,
+			"xmlSecBuffer",
+			"xmlSecBufferSetMaxSize",
+			XMLSEC_ERRORS_R_XMLSEC_FAILED,
+			"size=%d", size);
+	    return(-1);
+        }
+	
+	memcpy(buf->data, data, size);
+    }
+    
+    buf->size = size;    
+    return(0);
+}
+
+size_t 
+xmlSecBufferGetSize(xmlSecBufferPtr buf) {
+    xmlSecAssert2(buf != NULL, 0);
+
+    return(buf->size);
+}
+
+int 
+xmlSecBufferSetSize(xmlSecBufferPtr buf, size_t size) {
+    int ret;
+    
+    xmlSecAssert2(buf != NULL, -1);
+
+    ret = xmlSecBufferSetMaxSize(buf, size);
+    if(ret < 0) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlSecBufferSetMaxSize",
+		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+		    "size=%d", size);
+	return(-1);
+    }
+    
+    
+    buf->size = size;
+    return(0);
+}
+
+size_t 
+xmlSecBufferGetMaxSize(xmlSecBufferPtr buf) {
+    xmlSecAssert2(buf != NULL, 0);
+
+    return(buf->maxSize);
+}
+
+int 
+xmlSecBufferSetMaxSize(xmlSecBufferPtr buf, size_t size) {
+    unsigned char* newData;
+    size_t newSize;
+    
+    xmlSecAssert2(buf != NULL, -1);
+    if(size <= buf->maxSize) {
+	return(0);
+    }
+    
+    switch(buf->allocMode) {
+	case xmlSecAllocExact:
+	    newSize = size + 8;
+	    break;
+	case xmlSecAllocDouble:
+	    newSize = 2 * size + 8;
+	    break;
+	default:
+	    xmlSecError(XMLSEC_ERRORS_HERE,
+		        "xmlSecBuffer",
+			NULL,
+			XMLSEC_ERRORS_R_XMLSEC_FAILED,
+			"unknown allocation mode %d", buf->allocMode);
+	    return(-1);
+    }
+    
+    newData = (unsigned char*)xmlRealloc(buf->data, newSize);
+    if(newData == NULL) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlRealloc",
+		    XMLSEC_ERRORS_R_MALLOC_FAILED,
+		    "size=%d", newSize);
+	return(-1);
+    }
+    
+    buf->data = newData;
+    buf->maxSize = newSize;
+
+    if(buf->size < buf->maxSize) {
+	xmlSecAssert2(buf->data != NULL, -1);
+	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);
+    }
+    
+    return(0);
+}
+
+
+int 
+xmlSecBufferAppend(xmlSecBufferPtr buf, const unsigned char* data, size_t size) {
+    int ret;
+    
+    xmlSecAssert2(buf != NULL, -1);
+
+    if(size > 0) {
+	xmlSecAssert2(data != NULL, -1);
+    
+        ret = xmlSecBufferSetMaxSize(buf, buf->size + size);
+	if(ret < 0) {
+	    xmlSecError(XMLSEC_ERRORS_HERE,
+			"xmlSecBuffer",
+			"xmlSecBufferSetMaxSize",
+			XMLSEC_ERRORS_R_XMLSEC_FAILED,
+			"size=%d", buf->size + size);
+	    return(-1);
+	}
+	
+	memcpy(buf->data + buf->size, data, size);
+	buf->size += size;    
+    }
+    
+    return(0);
+}
+
+int
+xmlSecBufferPrepend(xmlSecBufferPtr buf, const unsigned char* data, size_t size) {
+    int ret;
+    
+    xmlSecAssert2(buf != NULL, -1);
+
+    if(size > 0) {
+	xmlSecAssert2(data != NULL, -1);
+    
+	ret = xmlSecBufferSetMaxSize(buf, buf->size + size);
+	if(ret < 0) {
+	    xmlSecError(XMLSEC_ERRORS_HERE,
+			"xmlSecBuffer",
+			"xmlSecBufferSetMaxSize",
+			XMLSEC_ERRORS_R_XMLSEC_FAILED,
+			"size=%d", buf->size + size);
+	    return(-1);
+	}
+
+	memmove(buf->data + size, buf->data, buf->size);	
+	memcpy(buf->data, data, size);
+	buf->size += size;    
+    }
+    
+    return(0);
+}
+
+int 
+xmlSecBufferRemoveHead(xmlSecBufferPtr buf, size_t size) {
+    xmlSecAssert2(buf != NULL, -1);
+    
+    if(size < buf->size) {
+	xmlSecAssert2(buf->data != NULL, -1);
+	
+	buf->size -= size;
+	memmove(buf->data, buf->data + size, buf->size);
+    } else {
+	buf->size = 0;
+    }
+    if(buf->size < buf->maxSize) {
+	xmlSecAssert2(buf->data != NULL, -1);
+	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);
+    }
+    return(0);
+}
+
+int 
+xmlSecBufferRemoveTail(xmlSecBufferPtr buf, size_t size) {
+    xmlSecAssert2(buf != NULL, -1);
+
+    if(size < buf->size) {
+	buf->size -= size;
+    } else {
+	buf->size = 0;
+    }
+    if(buf->size < buf->maxSize) {
+	xmlSecAssert2(buf->data != NULL, -1);
+	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);
+    }
+    return(0);
+}
+
+int 
+xmlSecBufferBase64NodeContentRead(xmlSecBufferPtr buf, xmlNodePtr node) {
+    xmlChar* content;
+    size_t size;
+    int ret;
+    
+    xmlSecAssert2(buf != NULL, -1);
+    xmlSecAssert2(node != NULL, -1);
+
+    content = xmlNodeGetContent(node);
+    if(content == NULL) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlNodeGetContent",
+		    XMLSEC_ERRORS_R_INVALID_NODE_CONTENT,
+		    "node=%s", (node->name != NULL) ? node->name : BAD_CAST "NULL");
+	return(-1);		
+    }
+    
+    /* base64 decode size is less than input size */
+    ret = xmlSecBufferSetMaxSize(buf, xmlStrlen(content));
+    if(ret < 0) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlSecBufferSetMaxSize",
+		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+		    XMLSEC_ERRORS_NO_MESSAGE);
+	xmlFree(content);
+	return(-1);
+    }
+    
+    ret = xmlSecBase64Decode(content, xmlSecBufferGetData(buf), xmlSecBufferGetMaxSize(buf));
+    if(ret < 0) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlSecBase64Decode",
+		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+		    XMLSEC_ERRORS_NO_MESSAGE);
+	xmlFree(content);
+	return(-1);
+    }
+    size = ret;
+
+    ret = xmlSecBufferSetSize(buf, size);
+    if(ret < 0) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlSecBufferSetSize",
+		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+		    "size=%d", size);
+	xmlFree(content);
+	return(-1);
+    }
+    xmlFree(content);
+    
+    return(0);
+}
+
+int 
+xmlSecBufferBase64NodeContentWrite(xmlSecBufferPtr buf, xmlNodePtr node, int columns) {
+    xmlChar* content;
+    
+    xmlSecAssert2(buf != NULL, -1);
+    xmlSecAssert2(node != NULL, -1);
+
+    content = xmlSecBase64Encode(xmlSecBufferGetData(buf), xmlSecBufferGetSize(buf), columns);
+    if(content == NULL) {
+	xmlSecError(XMLSEC_ERRORS_HERE,
+		    "xmlSecBuffer",
+		    "xmlSecBase64Encode",
+		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+		    XMLSEC_ERRORS_NO_MESSAGE);
+	return(-1);
+    }
+    xmlNodeAddContent(node, content);
+    xmlFree(content);
+    
+    return(0);
+}
+
+
diff --git a/src/keys.c b/src/keys.c
index c2fffd94..d4b25f3b 100644
--- a/src/keys.c
+++ b/src/keys.c
@@ -24,6 +24,52 @@
 #include <xmlsec/keyinfo.h>
 #include <xmlsec/errors.h>
 
+/**************************************************************************
+ *
+ * xmlSecKeyReq - what key are we looking for?
+ *
+ *************************************************************************/
+int 
+xmlSecKeyReqInitialize(xmlSecKeyReqPtr keyReq) {
+    xmlSecAssert2(keyReq != NULL, -1);
+    
+    memset(keyReq, 0, sizeof(xmlSecKeyReq));
+    return(0);
+}
+
+void
+xmlSecKeyReqFinalize(xmlSecKeyReqPtr keyReq) {
+    xmlSecAssert(keyReq != NULL);
+
+    memset(keyReq, 0, sizeof(xmlSecKeyReq));
+}
+
+int 
+xmlSecKeyReqCopy(xmlSecKeyReqPtr dst, xmlSecKeyReqPtr src) {
+    xmlSecAssert2(dst != NULL, -1);
+    xmlSecAssert2(src != NULL, -1);
+
+    memcpy(dst, src, sizeof(xmlSecKeyReq));
+    return(0);
+}
+
+int 
+xmlSecKeyReqValidate(xmlSecKeyReqPtr keyReq, xmlSecKeyPtr key) {
+    xmlSecKeyDataPtr value;
+    
+    xmlSecAssert2(keyReq != NULL, -1);
+    xmlSecAssert2(xmlSecKeyIsValid(key), -1);
+    
+    value = xmlSecKeyGetValue(key);
+    if(!xmlSecKeyDataCheckId(value, keyReq->keyId)) {
+	return(0);
+    }
+    if((xmlSecKeyGetType(key) & keyReq->keyType) == 0) {
+	 return(0);
+    }
+    /* todo: key usage! */
+    return(1);
+}
 
 /**
  * xmlSecKeyCreate:
diff --git a/src/membuf.c b/src/membuf.c
index c980ecfe..adc292e8 100644
--- a/src/membuf.c
+++ b/src/membuf.c
@@ -15,6 +15,7 @@
 #include <libxml/tree.h>
 
 #include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
 #include <xmlsec/keys.h>
 #include <xmlsec/transforms.h>
 #include <xmlsec/transformsInternal.h>
@@ -23,368 +24,6 @@
 #include <xmlsec/membuf.h>
 #include <xmlsec/errors.h>
 
-/*****************************************************************************
- *
- * xmlSecBuffer
- *
- ****************************************************************************/
-xmlSecBufferPtr 
-xmlSecBufferCreate(size_t size) {
-    xmlSecBufferPtr buf;
-    int ret;
-    
-    buf = (xmlSecBufferPtr)xmlMalloc(sizeof(xmlSecBuffer));
-    if(buf == NULL) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlMalloc",
-		    XMLSEC_ERRORS_R_MALLOC_FAILED,
-		    "sizeof(xmlSecBuffer)=%d", sizeof(xmlSecBuffer));
-	return(NULL);
-    }
-
-    ret = xmlSecBufferInitialize(buf, size);
-    if(ret < 0) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlSecBufferInitialize",
-		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
-		    "size=%d", size);
-	xmlSecBufferDestroy(buf);
-	return(NULL);
-    }
-    
-    return(buf);
-}
-
-void 
-xmlSecBufferDestroy(xmlSecBufferPtr buf) {
-    xmlSecAssert(buf != NULL);
-    
-    xmlSecBufferFinalize(buf);
-    xmlFree(buf);
-}
-
-int 
-xmlSecBufferInitialize(xmlSecBufferPtr buf, size_t size) {
-    xmlSecAssert2(buf != NULL, -1);
-
-    buf->data = NULL;
-    buf->size = buf->maxSize = 0;
-    buf->allocMode = xmlSecAllocExact;
-        
-    return(xmlSecBufferSetMaxSize(buf, size));
-}
-
-void 
-xmlSecBufferFinalize(xmlSecBufferPtr buf) {
-    xmlSecAssert(buf != NULL);
-
-    xmlSecBufferEmpty(buf);    
-    if(buf->data != 0) {
-	xmlFree(buf->data);
-    }
-    buf->data = NULL;
-    buf->size = buf->maxSize = 0;
-}
-
-void
-xmlSecBufferEmpty(xmlSecBufferPtr buf) {
-    xmlSecAssert(buf != NULL);
-    
-    if(buf->data != 0) {
-	xmlSecAssert(buf->maxSize > 0);
-
-	memset(buf->data, 0, buf->maxSize);
-    }
-    buf->size = 0;
-}
-
-unsigned char* 
-xmlSecBufferGetData(xmlSecBufferPtr buf) {
-    xmlSecAssert2(buf != NULL, NULL);
-    
-    return(buf->data);
-}
-
-int 
-xmlSecBufferSetData(xmlSecBufferPtr buf, const unsigned char* data, size_t size) {
-    int ret;
-    
-    xmlSecAssert2(buf != NULL, -1);
-
-    xmlSecBufferEmpty(buf);
-    if(size > 0) {
-	xmlSecAssert2(data != NULL, -1);
-    
-	ret = xmlSecBufferSetMaxSize(buf, size);
-	if(ret < 0) {
-	    xmlSecError(XMLSEC_ERRORS_HERE,
-			"xmlSecBuffer",
-			"xmlSecBufferSetMaxSize",
-			XMLSEC_ERRORS_R_XMLSEC_FAILED,
-			"size=%d", size);
-	    return(-1);
-        }
-	
-	memcpy(buf->data, data, size);
-    }
-    
-    buf->size = size;    
-    return(0);
-}
-
-size_t 
-xmlSecBufferGetSize(xmlSecBufferPtr buf) {
-    xmlSecAssert2(buf != NULL, 0);
-
-    return(buf->size);
-}
-
-int 
-xmlSecBufferSetSize(xmlSecBufferPtr buf, size_t size) {
-    int ret;
-    
-    xmlSecAssert2(buf != NULL, -1);
-
-    ret = xmlSecBufferSetMaxSize(buf, size);
-    if(ret < 0) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlSecBufferSetMaxSize",
-		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
-		    "size=%d", size);
-	return(-1);
-    }
-    
-    
-    buf->size = size;
-    return(0);
-}
-
-size_t 
-xmlSecBufferGetMaxSize(xmlSecBufferPtr buf) {
-    xmlSecAssert2(buf != NULL, 0);
-
-    return(buf->maxSize);
-}
-
-int 
-xmlSecBufferSetMaxSize(xmlSecBufferPtr buf, size_t size) {
-    unsigned char* newData;
-    size_t newSize;
-    
-    xmlSecAssert2(buf != NULL, -1);
-    if(size <= buf->maxSize) {
-	return(0);
-    }
-    
-    switch(buf->allocMode) {
-	case xmlSecAllocExact:
-	    newSize = size + 8;
-	    break;
-	case xmlSecAllocDouble:
-	    newSize = 2 * size + 8;
-	    break;
-	default:
-	    xmlSecError(XMLSEC_ERRORS_HERE,
-		        "xmlSecBuffer",
-			NULL,
-			XMLSEC_ERRORS_R_XMLSEC_FAILED,
-			"unknown allocation mode %d", buf->allocMode);
-	    return(-1);
-    }
-    
-    newData = (unsigned char*)xmlRealloc(buf->data, newSize);
-    if(newData == NULL) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlRealloc",
-		    XMLSEC_ERRORS_R_MALLOC_FAILED,
-		    "size=%d", newSize);
-	return(-1);
-    }
-    
-    buf->data = newData;
-    buf->maxSize = newSize;
-
-    if(buf->size < buf->maxSize) {
-	xmlSecAssert2(buf->data != NULL, -1);
-	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);
-    }
-    
-    return(0);
-}
-
-
-int 
-xmlSecBufferAppend(xmlSecBufferPtr buf, const unsigned char* data, size_t size) {
-    int ret;
-    
-    xmlSecAssert2(buf != NULL, -1);
-
-    if(size > 0) {
-	xmlSecAssert2(data != NULL, -1);
-    
-        ret = xmlSecBufferSetMaxSize(buf, buf->size + size);
-	if(ret < 0) {
-	    xmlSecError(XMLSEC_ERRORS_HERE,
-			"xmlSecBuffer",
-			"xmlSecBufferSetMaxSize",
-			XMLSEC_ERRORS_R_XMLSEC_FAILED,
-			"size=%d", buf->size + size);
-	    return(-1);
-	}
-	
-	memcpy(buf->data + buf->size, data, size);
-	buf->size += size;    
-    }
-    
-    return(0);
-}
-
-int
-xmlSecBufferPrepend(xmlSecBufferPtr buf, const unsigned char* data, size_t size) {
-    int ret;
-    
-    xmlSecAssert2(buf != NULL, -1);
-
-    if(size > 0) {
-	xmlSecAssert2(data != NULL, -1);
-    
-	ret = xmlSecBufferSetMaxSize(buf, buf->size + size);
-	if(ret < 0) {
-	    xmlSecError(XMLSEC_ERRORS_HERE,
-			"xmlSecBuffer",
-			"xmlSecBufferSetMaxSize",
-			XMLSEC_ERRORS_R_XMLSEC_FAILED,
-			"size=%d", buf->size + size);
-	    return(-1);
-	}
-
-	memmove(buf->data + size, buf->data, buf->size);	
-	memcpy(buf->data, data, size);
-	buf->size += size;    
-    }
-    
-    return(0);
-}
-
-int 
-xmlSecBufferRemoveHead(xmlSecBufferPtr buf, size_t size) {
-    xmlSecAssert2(buf != NULL, -1);
-    
-    if(size < buf->size) {
-	xmlSecAssert2(buf->data != NULL, -1);
-	
-	buf->size -= size;
-	memmove(buf->data, buf->data + size, buf->size);
-    } else {
-	buf->size = 0;
-    }
-    if(buf->size < buf->maxSize) {
-	xmlSecAssert2(buf->data != NULL, -1);
-	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);
-    }
-    return(0);
-}
-
-int 
-xmlSecBufferRemoveTail(xmlSecBufferPtr buf, size_t size) {
-    xmlSecAssert2(buf != NULL, -1);
-
-    if(size < buf->size) {
-	buf->size -= size;
-    } else {
-	buf->size = 0;
-    }
-    if(buf->size < buf->maxSize) {
-	xmlSecAssert2(buf->data != NULL, -1);
-	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);
-    }
-    return(0);
-}
-
-int 
-xmlSecBufferBase64NodeContentRead(xmlSecBufferPtr buf, xmlNodePtr node) {
-    xmlChar* content;
-    size_t size;
-    int ret;
-    
-    xmlSecAssert2(buf != NULL, -1);
-    xmlSecAssert2(node != NULL, -1);
-
-    content = xmlNodeGetContent(node);
-    if(content == NULL) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlNodeGetContent",
-		    XMLSEC_ERRORS_R_INVALID_NODE_CONTENT,
-		    "node=%s", (node->name != NULL) ? node->name : BAD_CAST "NULL");
-	return(-1);		
-    }
-    
-    /* base64 decode size is less than input size */
-    ret = xmlSecBufferSetMaxSize(buf, xmlStrlen(content));
-    if(ret < 0) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlSecBufferSetMaxSize",
-		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
-		    XMLSEC_ERRORS_NO_MESSAGE);
-	xmlFree(content);
-	return(-1);
-    }
-    
-    ret = xmlSecBase64Decode(content, xmlSecBufferGetData(buf), xmlSecBufferGetMaxSize(buf));
-    if(ret < 0) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlSecBase64Decode",
-		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
-		    XMLSEC_ERRORS_NO_MESSAGE);
-	xmlFree(content);
-	return(-1);
-    }
-    size = ret;
-
-    ret = xmlSecBufferSetSize(buf, size);
-    if(ret < 0) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlSecBufferSetSize",
-		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
-		    "size=%d", size);
-	xmlFree(content);
-	return(-1);
-    }
-    xmlFree(content);
-    
-    return(0);
-}
-
-int 
-xmlSecBufferBase64NodeContentWrite(xmlSecBufferPtr buf, xmlNodePtr node, int columns) {
-    xmlChar* content;
-    
-    xmlSecAssert2(buf != NULL, -1);
-    xmlSecAssert2(node != NULL, -1);
-
-    content = xmlSecBase64Encode(xmlSecBufferGetData(buf), xmlSecBufferGetSize(buf), columns);
-    if(content == NULL) {
-	xmlSecError(XMLSEC_ERRORS_HERE,
-		    "xmlSecBuffer",
-		    "xmlSecBase64Encode",
-		    XMLSEC_ERRORS_R_XMLSEC_FAILED,
-		    XMLSEC_ERRORS_NO_MESSAGE);
-	return(-1);
-    }
-    xmlNodeAddContent(node, content);
-    xmlFree(content);
-    
-    return(0);
-}
-
 
 /*****************************************************************************
  *
diff --git a/src/openssl/bn.c b/src/openssl/bn.c
index 2cefa0e3..71c92eae 100644
--- a/src/openssl/bn.c
+++ b/src/openssl/bn.c
@@ -15,8 +15,7 @@
 #include <libxml/tree.h> 
 
 #include <xmlsec/xmlsec.h>
-#include <xmlsec/transformsInternal.h>
-#include <xmlsec/membuf.h>
+#include <xmlsec/buffer.h>
 #include <xmlsec/errors.h>
 
 #include <xmlsec/openssl/crypto.h>
diff --git a/src/openssl/kt_rsa.c b/src/openssl/kt_rsa.c
index 5220aef6..991a6bb7 100644
--- a/src/openssl/kt_rsa.c
+++ b/src/openssl/kt_rsa.c
@@ -23,12 +23,12 @@
 #include <libxml/tree.h>
 
 #include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
 #include <xmlsec/xmltree.h>
 #include <xmlsec/keys.h>
 #include <xmlsec/keyinfo.h>
 #include <xmlsec/transforms.h>
 #include <xmlsec/transformsInternal.h>
-#include <xmlsec/membuf.h>
 #include <xmlsec/strings.h>
 #include <xmlsec/debug.h>
 #include <xmlsec/errors.h>
diff --git a/src/transforms-old.c b/src/transforms-old.c
index 65f6b7c8..bf88a153 100644
--- a/src/transforms-old.c
+++ b/src/transforms-old.c
@@ -1,4 +1,5 @@
 #include <xmlsec/transformsInternal.h>
+#include <xmlsec/membuf.h>
 
 static xmlSecTransformId xmlSecAllTransformIds[100];
 
diff --git a/src/transforms.c b/src/transforms.c
index 8ea81446..26b1c0c5 100644
--- a/src/transforms.c
+++ b/src/transforms.c
@@ -48,11 +48,11 @@
 #include <libxml/xpointer.h>
 
 #include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
 #include <xmlsec/xmltree.h>
 #include <xmlsec/keyinfo.h>
 #include <xmlsec/transforms.h>
 #include <xmlsec/io.h>
-#include <xmlsec/membuf.h>
 #include <xmlsec/base64.h>
 #include <xmlsec/errors.h>
 
diff --git a/src/xmldsig.c b/src/xmldsig.c
index b649e181..23a7957e 100644
--- a/src/xmldsig.c
+++ b/src/xmldsig.c
@@ -21,6 +21,7 @@
 #include <libxml/parser.h> 
 
 #include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
 #include <xmlsec/xmltree.h>
 #include <xmlsec/keys.h>
 #include <xmlsec/keysmngr.h>
diff --git a/src/xmlenc.c b/src/xmlenc.c
index 8e0270a0..a7bab2a7 100644
--- a/src/xmlenc.c
+++ b/src/xmlenc.c
@@ -20,6 +20,7 @@
 #include <libxml/parser.h> 
 
 #include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
 #include <xmlsec/xmltree.h>
 #include <xmlsec/keys.h>
 #include <xmlsec/keysmngr.h>
diff --git a/src/xslt.c b/src/xslt.c
index 00f29d29..4d181991 100644
--- a/src/xslt.c
+++ b/src/xslt.c
@@ -53,15 +53,28 @@
 #include <xmlsec/keys.h>
 #include <xmlsec/errors.h>
 
+/**************************************************************************
+ *
+ * Internal xslt ctx
+ *
+ *****************************************************************************/
+typedef struct _xmlSecXsltCtx			xmlSecXsltCtx, *xmlSecXsltCtxPtr;
+struct _xmlSecXsltCtx {
+    xsltStylesheetPtr	xslt;
+};	    
+
 /****************************************************************************
  *
  * XSLT transform
  *
- * resereved0 --> parsed stylesheet (xsltStylesheetPtr)
+ * xmlSecXsltCtx is located after xmlSecTransform
  * 
  ***************************************************************************/
-#define xmlSecXsltGetStylesheet(transform) \
-    ((xsltStylesheetPtr)((transform)->reserved0))
+#define xmlSecXsltSize	\
+    (sizeof(xmlSecTransform) + sizeof(xmlSecXsltCtx))	
+#define xmlSecXsltGetCtx(transform) \
+    ((xmlSecXsltCtxPtr)(((unsigned char*)(transform)) + sizeof(xmlSecTransform)))
+
 static int		xmlSecXsltInitialize			(xmlSecTransformPtr transform);
 static void		xmlSecXsltFinalize			(xmlSecTransformPtr transform);
 static int 		xmlSecXsltReadNode			(xmlSecTransformPtr transform,
@@ -75,7 +88,7 @@ static int		xmlSecXslProcess			(xmlSecBufferPtr in,
 static xmlSecTransformKlass xmlSecXsltKlass = {
     /* klass/object sizes */
     sizeof(xmlSecTransformKlass),		/* size_t klassSize */
-    sizeof(xmlSecTransform),			/* size_t objSize */
+    xmlSecXsltSize,				/* size_t objSize */
 
     xmlSecNameXslt,				/* const xmlChar* name; */
     xmlSecTransformTypeBinary,			/* xmlSecTransformType type; */
@@ -105,20 +118,33 @@ xmlSecTransformXsltGetKlass(void) {
     
 static int 
 xmlSecXsltInitialize(xmlSecTransformPtr transform) {    
+    xmlSecXsltCtxPtr ctx;
+    
     xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformXsltId), -1);
+    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecXsltSize), -1);
 
-    transform->reserved0 = NULL;    
+    ctx = xmlSecXsltGetCtx(transform);
+    xmlSecAssert2(ctx != NULL, -1);
+    
+    /* initialize context */
+    memset(ctx, 0, sizeof(xmlSecXsltCtx));
     return(0);
 }
 
 static void
 xmlSecXsltFinalize(xmlSecTransformPtr transform) {
+    xmlSecXsltCtxPtr ctx;
+
     xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformXsltId));
+    xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecXsltSize));
+
+    ctx = xmlSecXsltGetCtx(transform);
+    xmlSecAssert(ctx != NULL);
     
-    if(xmlSecXsltGetStylesheet(transform) != NULL) {
-	xsltFreeStylesheet(xmlSecXsltGetStylesheet(transform));
+    if(ctx->xslt != NULL) {
+	xsltFreeStylesheet(ctx->xslt);
     }
-    transform->reserved0 = NULL;    
+    memset(ctx, 0, sizeof(xmlSecXsltCtx));
 }
 
 /**
@@ -126,14 +152,19 @@ xmlSecXsltFinalize(xmlSecTransformPtr transform) {
  */
 static int
 xmlSecXsltReadNode(xmlSecTransformPtr transform, xmlNodePtr node) {
+    xmlSecXsltCtxPtr ctx;
     xmlBufferPtr buffer;
     xmlDocPtr doc;
     xmlNodePtr cur;
     
     xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformXsltId), -1);
-    xmlSecAssert2(xmlSecXsltGetStylesheet(transform) == NULL, -1);
+    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecXsltSize), -1);
     xmlSecAssert2(node != NULL, -1);    
 
+    ctx = xmlSecXsltGetCtx(transform);
+    xmlSecAssert2(ctx != NULL, -1);
+    xmlSecAssert2(ctx->xslt == NULL, -1);
+
     /* read content in the buffer */    
     buffer = xmlBufferCreate();
     if(buffer == NULL) {
@@ -164,8 +195,8 @@ xmlSecXsltReadNode(xmlSecTransformPtr transform, xmlNodePtr node) {
     }
 
     /* pre-process stylesheet */    
-    transform->reserved0 = xsltParseStylesheetDoc(doc);
-    if(transform->reserved0 == NULL) {
+    ctx->xslt = xsltParseStylesheetDoc(doc);
+    if(ctx->xslt == NULL) {
 	xmlSecError(XMLSEC_ERRORS_HERE,
 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 		    "xsltParseStylesheetDoc",
@@ -184,14 +215,19 @@ xmlSecXsltReadNode(xmlSecTransformPtr transform, xmlNodePtr node) {
 
 static int 
 xmlSecXsltExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr transformCtx) {
+    xmlSecXsltCtxPtr ctx;
     xmlSecBufferPtr in, out;
     size_t inSize, outSize;
     int ret;
 
     xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformXsltId), -1);
-    xmlSecAssert2(xmlSecXsltGetStylesheet(transform) != NULL, -1);
+    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecXsltSize), -1);
     xmlSecAssert2(transformCtx != NULL, -1);
 
+    ctx = xmlSecXsltGetCtx(transform);
+    xmlSecAssert2(ctx != NULL, -1);
+    xmlSecAssert2(ctx->xslt != NULL, -1);
+
     in = &(transform->inBuf);
     out = &(transform->outBuf);
     inSize = xmlSecBufferGetSize(in);
@@ -206,7 +242,7 @@ xmlSecXsltExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr
     } else  if((transform->status == xmlSecTransformStatusWorking) && (last != 0)) {
 	xmlSecAssert2(outSize == 0, -1);
 
-	ret = xmlSecXslProcess(in, out, xmlSecXsltGetStylesheet(transform));
+	ret = xmlSecXslProcess(in, out, ctx->xslt);
 	if(ret < 0) {
 	    xmlSecError(XMLSEC_ERRORS_HERE, 
 			xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
@@ -222,7 +258,7 @@ xmlSecXsltExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr
 			xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 			"xmlSecBufferRemoveHead",
 			XMLSEC_ERRORS_R_XMLSEC_FAILED,
-			"%d", inSize);
+			"size=%d", inSize);
 	    return(-1);
 	}
 	
@@ -235,7 +271,7 @@ xmlSecXsltExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr
 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 		    NULL,
 		    XMLSEC_ERRORS_R_INVALID_STATUS,
-		    "%d", transform->status);
+		    "status=%d", transform->status);
 	return(-1);
     }
     return(0);
@@ -294,7 +330,7 @@ xmlSecXslProcess(xmlSecBufferPtr in, xmlSecBufferPtr out,  xsltStylesheetPtr sty
     }
 
     ret = xmlSecBufferSetData(out, xmlBufferContent(output->buffer), 
-			    xmlBufferLength(output->buffer));
+			      xmlBufferLength(output->buffer));
     if(ret < 0) {
 	xmlSecError(XMLSEC_ERRORS_HERE,
 		    NULL,
diff --git a/xmlsec.pc b/xmlsec.pc
index 7136c14d..532fff38 100644
--- a/xmlsec.pc
+++ b/xmlsec.pc
@@ -4,8 +4,8 @@ libdir=${exec_prefix}/lib
 includedir=${prefix}/include
 
 Name: xmlsec
-Version: 0.1.0-nss
+Version: 0.1.0-openssl
 Description: XML Security Library implements XML Signature and XML Encryption standards
 Requires: libxml-2.0 >= 2.4.24 libxslt >= 1.0.20 
-Libs: -lxmlsec-nss -lxmlsec -L/home/aleksey/lib -lxml2 -lz -lm -L/home/aleksey/lib -lxslt -lxml2 -lz -lm -L/usr/lib -lnss3 -lnspr4 -lplds4 -lplc4 
-Cflags: -I${includedir}/xmlsec @XMLSEC_CFLAGS@ -DXMLSEC_CRYPTO=\"nss\"
+Libs: -lxmlsec-openssl -lxmlsec -L/home/aleksey/lib -lxml2 -lz -lm -L/home/aleksey/lib -lxslt -lxml2 -lz -lm -L/home/aleksey/lib -lcrypto 
+Cflags: -I${includedir}/xmlsec @XMLSEC_CFLAGS@ -DXMLSEC_CRYPTO=\"openssl\"