1 /** 

     2  * XML Security Library (http://www.aleksey.com/xmlsec).

     3  *

     4  * Memory buffer.

     5  *

     6  * This is free software; see Copyright file in the source

     7  * distribution for preciese wording.

     8  * 

     9  * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>

    10  * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

    11  */

    12 #include "xmlsec_globals.h"

    13 

    14 #include <stdlib.h>

    15 #include <string.h>

    16 #include <ctype.h>

    17 #include <errno.h>

    18 

    19 #include <libxml2_tree.h>

    20 #include <libxml2_globals.h>

    21 

    22 #include "xmlsec_xmlsec.h"

    23 #include "xmlsec_xmltree.h"

    24 #include "xmlsec_base64.h"

    25 #include "xmlsec_buffer.h"

    26 #include "xmlsec_errors.h"

    27 

    28 #include "xmlsec_error_flag.h"

    29 

    30 //added for symbian port

    31 #include "xmlsec_io.h"

    32 

    33 /*****************************************************************************

    34  *

    35  * xmlSecBuffer

    36  *

    37  ****************************************************************************/

    38 static xmlSecAllocMode gAllocMode = xmlSecAllocModeDouble;

    39 static xmlSecSize gInitialSize = 1024;

    40 

    41 /**

    42  * xmlSecBufferSetDefaultAllocMode:

    43  * @defAllocMode:	the new default buffer allocation mode.

    44  * @defInitialSize:	the new default buffer minimal intial size.

    45  * 

    46  * Sets new global default allocation mode and minimal intial size.

    47  */

    48 EXPORT_C

    49 void 

    50 xmlSecBufferSetDefaultAllocMode(xmlSecAllocMode defAllocMode, xmlSecSize defInitialSize) {

    51     xmlSecAssert(defInitialSize > 0);

    52     

    53     gAllocMode = defAllocMode;

    54     gInitialSize = defInitialSize;

    55 }

    56 

    57 /**

    58  * xmlSecBufferCreate:

    59  * @size: 		the intial size.

    60  *

    61  * Allocates and initalizes new memory buffer with given size.

    62  * Caller is responsible for calling #xmlSecBufferDestroy function

    63  * to free the buffer.

    64  *

    65  * Returns pointer to newly allocated buffer or NULL if an error occurs.

    66  */

    67 EXPORT_C

    68 xmlSecBufferPtr 

    69 xmlSecBufferCreate(xmlSecSize size) {

    70     xmlSecBufferPtr buf;

    71     int ret;

    72     

    73     buf = (xmlSecBufferPtr)xmlMalloc(sizeof(xmlSecBuffer));

    74     if(buf == NULL) {

    75 	xmlSecError(XMLSEC_ERRORS_HERE,

    76 		    NULL,

    77 		    NULL,

    78 		    XMLSEC_ERRORS_R_MALLOC_FAILED,

    79 		    "sizeof(xmlSecBuffer)=%d", sizeof(xmlSecBuffer));

    80 	return(NULL);

    81     }

    82     

    83     ret = xmlSecBufferInitialize(buf, size);

    84     if(ret < 0) {

    85 	xmlSecError(XMLSEC_ERRORS_HERE,

    86 		    NULL,

    87 		    "xmlSecBufferInitialize",

    88 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

    89 		    "size=%d", size);

    90 	xmlSecBufferDestroy(buf);

    91 	return(NULL);

    92     }

    93     return(buf);

    94 }

    95 

    96 /**

    97  * xmlSecBufferDestroy:

    98  * @buf:		the pointer to buffer object.

    99  *

   100  * Desrtoys buffer object created with #xmlSecBufferCreate function.

   101  */

   102 EXPORT_C

   103 void 

   104 xmlSecBufferDestroy(xmlSecBufferPtr buf) {

   105     xmlSecAssert(buf != NULL);

   106     

   107     xmlSecBufferFinalize(buf);

   108     xmlFree(buf);

   109 }

   110 

   111 /**

   112  * xmlSecBufferInitialize:

   113  * @buf:		the pointer to buffer object.

   114  * @size:		the initial buffer size.

   115  *

   116  * Initializes buffer object @buf. Caller is responsible for calling

   117  * #xmlSecBufferFinalize function to free allocated resources.

   118  * 

   119  * Returns 0 on success or a negative value if an error occurs.

   120  */

   121 EXPORT_C

   122 int 

   123 xmlSecBufferInitialize(xmlSecBufferPtr buf, xmlSecSize size) {

   124     xmlSecAssert2(buf != NULL, -1);

   125 

   126     buf->data = NULL;

   127     buf->size = buf->maxSize = 0;

   128     buf->allocMode = gAllocMode;

   129         

   130     return(xmlSecBufferSetMaxSize(buf, size));

   131 }

   132 

   133 /**

   134  * xmlSecBufferFinalize:

   135  * @buf:		the pointer to buffer object.

   136  *

   137  * Frees allocated resource for a buffer intialized with #xmlSecBufferInitialize

   138  * function.

   139  */

   140 EXPORT_C

   141 void 

   142 xmlSecBufferFinalize(xmlSecBufferPtr buf) {

   143     xmlSecAssert(buf != NULL);

   144 

   145     xmlSecBufferEmpty(buf);    

   146     if(buf->data != 0) {

   147 	xmlFree(buf->data);

   148     }

   149     buf->data = NULL;

   150     buf->size = buf->maxSize = 0;

   151 }

   152 

   153 /**

   154  * xmlSecBufferEmpty:

   155  * @buf:		the pointer to buffer object.

   156  *

   157  * Empties the buffer.

   158  */

   159 EXPORT_C

   160 void

   161 xmlSecBufferEmpty(xmlSecBufferPtr buf) {

   162     xmlSecAssert(buf != NULL);

   163     

   164     if(buf->data != 0) {

   165 	xmlSecAssert(buf->maxSize > 0);

   166 

   167 	memset(buf->data, 0, buf->maxSize);

   168     }

   169     buf->size = 0;

   170 }

   171 

   172 /**

   173  * xmlSecBufferGetData:

   174  * @buf:		the pointer to buffer object.

   175  *

   176  * Gets pointer to buffer's data.

   177  *

   178  * Returns pointer to buffer's data.

   179  */

   180 EXPORT_C

   181 xmlSecByte* 

   182 xmlSecBufferGetData(xmlSecBufferPtr buf) {

   183     xmlSecAssert2(buf != NULL, NULL);

   184     

   185     return(buf->data);

   186 }

   187 

   188 /**

   189  * xmlSecBufferSetData:

   190  * @buf:		the pointer to buffer object.

   191  * @data:		the data.

   192  * @size:		the data size.

   193  *

   194  * Sets the value of the buffer to @data.

   195  *

   196  * Returns 0 on success or a negative value if an error occurs.

   197  */

   198 EXPORT_C

   199 int 

   200 xmlSecBufferSetData(xmlSecBufferPtr buf, const xmlSecByte* data, xmlSecSize size) {

   201     int ret;

   202     

   203     xmlSecAssert2(buf != NULL, -1);

   204 

   205     xmlSecBufferEmpty(buf);

   206     if(size > 0) {

   207 	xmlSecAssert2(data != NULL, -1);

   208     

   209 	ret = xmlSecBufferSetMaxSize(buf, size);

   210 	if(ret < 0) {

   211 	    xmlSecError(XMLSEC_ERRORS_HERE,

   212 			NULL,

   213 			"xmlSecBufferSetMaxSize",

   214 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   215 			"size=%d", size);

   216 	    return(-1);

   217         }

   218 	

   219 	memcpy(buf->data, data, size);

   220     }

   221     

   222     buf->size = size;    

   223     return(0);

   224 }

   225 

   226 /**

   227  * xmlSecBufferGetSize:

   228  * @buf:		the pointer to buffer object.

   229  *

   230  * Gets the current buffer data size.

   231  *

   232  * Returns the current data size.

   233  */

   234 EXPORT_C

   235 xmlSecSize 

   236 xmlSecBufferGetSize(xmlSecBufferPtr buf) {

   237     xmlSecAssert2(buf != NULL, 0);

   238 

   239     return(buf->size);

   240 }

   241 

   242 /**

   243  * xmlSecBufferSetSize:

   244  * @buf:		the pointer to buffer object.

   245  * @size:		the new data size.

   246  *

   247  * Sets new buffer data size. If necessary, buffer grows to 

   248  * have at least @size bytes. 

   249  *

   250  * Returns 0 on success or a negative value if an error occurs.

   251  */

   252 EXPORT_C

   253 int 

   254 xmlSecBufferSetSize(xmlSecBufferPtr buf, xmlSecSize size) {

   255     int ret;

   256     

   257     xmlSecAssert2(buf != NULL, -1);

   258 

   259     ret = xmlSecBufferSetMaxSize(buf, size);

   260     if(ret < 0) {

   261 	xmlSecError(XMLSEC_ERRORS_HERE,

   262 		    NULL,

   263 		    "xmlSecBufferSetMaxSize",

   264 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   265 		    "size=%d", size);

   266 	return(-1);

   267     }

   268     

   269     

   270     buf->size = size;

   271     return(0);

   272 }

   273 

   274 /**

   275  * xmlSecBufferGetMaxSize:

   276  * @buf:		the pointer to buffer object.

   277  *

   278  * Gets the maximum (allocated) buffer size.

   279  *

   280  * Returns the maximum (allocated) buffer size.

   281  */

   282 EXPORT_C

   283 xmlSecSize 

   284 xmlSecBufferGetMaxSize(xmlSecBufferPtr buf) {

   285     xmlSecAssert2(buf != NULL, 0);

   286 

   287     return(buf->maxSize);

   288 }

   289 

   290 /**

   291  * xmlSecBufferSetMaxSize:

   292  * @buf:		the pointer to buffer object.

   293  * @size:		the new maximum size.

   294  *

   295  * Sets new buffer maximum size. If necessary, buffer grows to 

   296  * have at least @size bytes. 

   297  *

   298  * Returns 0 on success or a negative value if an error occurs.

   299  */

   300 EXPORT_C

   301 int 

   302 xmlSecBufferSetMaxSize(xmlSecBufferPtr buf, xmlSecSize size) {

   303     xmlSecByte* newData;

   304     xmlSecSize newSize = 0;

   305     

   306     xmlSecAssert2(buf != NULL, -1);

   307     if(size <= buf->maxSize) {

   308 	return(0);

   309     }

   310     

   311     switch(buf->allocMode) {

   312 	case xmlSecAllocModeExact:

   313 	    newSize = size + 8;

   314 	    break;

   315 	case xmlSecAllocModeDouble:

   316 	    newSize = 2 * size + 32;

   317 	    break;

   318     }

   319 

   320     if(newSize < gInitialSize) {

   321 	newSize = gInitialSize;

   322     }

   323     

   324 

   325     if(buf->data != NULL) {

   326     	newData = (xmlSecByte*)xmlRealloc(buf->data, newSize);

   327     } else {

   328     	newData = (xmlSecByte*)xmlMalloc(newSize);

   329     }

   330     if(newData == NULL) {

   331 	xmlSecError(XMLSEC_ERRORS_HERE,

   332 		    NULL,

   333 		    NULL,

   334 		    XMLSEC_ERRORS_R_MALLOC_FAILED,

   335 		    "size=%d", newSize);

   336 	return(-1);

   337     }

   338     

   339     buf->data = newData;

   340     buf->maxSize = newSize;

   341 

   342     if(buf->size < buf->maxSize) {

   343 	xmlSecAssert2(buf->data != NULL, -1);

   344 	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);

   345     }

   346     

   347     return(0);

   348 }

   349 

   350 /**

   351  * xmlSecBufferAppend:

   352  * @buf:		the pointer to buffer object.

   353  * @data:		the data.

   354  * @size:		the data size.

   355  *

   356  * Appends the @data after the current data stored in the buffer.

   357  *

   358  * Returns 0 on success or a negative value if an error occurs.

   359  */

   360 EXPORT_C

   361 int 

   362 xmlSecBufferAppend(xmlSecBufferPtr buf, const xmlSecByte* data, xmlSecSize size) {

   363     int ret;

   364     

   365     xmlSecAssert2(buf != NULL, -1);

   366 

   367     if(size > 0) {

   368 	xmlSecAssert2(data != NULL, -1);

   369     

   370         ret = xmlSecBufferSetMaxSize(buf, buf->size + size);

   371 	if(ret < 0) {

   372 	    xmlSecError(XMLSEC_ERRORS_HERE,

   373 			NULL,

   374 			"xmlSecBufferSetMaxSize",

   375 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   376 			"size=%d", buf->size + size);

   377 	    return(-1);

   378 	}

   379 	

   380 	memcpy(buf->data + buf->size, data, size);

   381 	buf->size += size;    

   382     }

   383     

   384     return(0);

   385 }

   386 

   387 /**

   388  * xmlSecBufferPrepend:

   389  * @buf:		the pointer to buffer object.

   390  * @data:		the data.

   391  * @size:		the data size.

   392  *

   393  * Prepends the @data before the current data stored in the buffer.

   394  *

   395  * Returns 0 on success or a negative value if an error occurs.

   396  */

   397 EXPORT_C

   398 int

   399 xmlSecBufferPrepend(xmlSecBufferPtr buf, const xmlSecByte* data, xmlSecSize size) {

   400     int ret;

   401     

   402     xmlSecAssert2(buf != NULL, -1);

   403 

   404     if(size > 0) {

   405 	xmlSecAssert2(data != NULL, -1);

   406     

   407 	ret = xmlSecBufferSetMaxSize(buf, buf->size + size);

   408 	if(ret < 0) {

   409 	    xmlSecError(XMLSEC_ERRORS_HERE,

   410 			NULL,

   411 			"xmlSecBufferSetMaxSize",

   412 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   413 			"size=%d", buf->size + size);

   414 	    return(-1);

   415 	}

   416 

   417 	memmove(buf->data + size, buf->data, buf->size);	

   418 	memcpy(buf->data, data, size);

   419 	buf->size += size;    

   420     }

   421     

   422     return(0);

   423 }

   424 

   425 /**

   426  * xmlSecBufferRemoveHead:

   427  * @buf:		the pointer to buffer object.

   428  * @size:		the number of bytes to be removed.

   429  *

   430  * Removes @size bytes from the beginning of the current buffer.

   431  *

   432  * Returns 0 on success or a negative value if an error occurs.

   433  */

   434 EXPORT_C

   435 int 

   436 xmlSecBufferRemoveHead(xmlSecBufferPtr buf, xmlSecSize size) {

   437     xmlSecAssert2(buf != NULL, -1);

   438     

   439     if(size < buf->size) {

   440 	xmlSecAssert2(buf->data != NULL, -1);

   441 	

   442 	buf->size -= size;

   443 	memmove(buf->data, buf->data + size, buf->size);

   444     } else {

   445 	buf->size = 0;

   446     }

   447     if(buf->size < buf->maxSize) {

   448 	xmlSecAssert2(buf->data != NULL, -1);

   449 	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);

   450     }

   451     return(0);

   452 }

   453 

   454 /**

   455  * xmlSecBufferRemoveTail:

   456  * @buf:		the pointer to buffer object.

   457  * @size:		the number of bytes to be removed.

   458  *

   459  * Removes @size bytes from the end of current buffer.

   460  *

   461  * Returns 0 on success or a negative value if an error occurs.

   462  */

   463 EXPORT_C

   464 int 

   465 xmlSecBufferRemoveTail(xmlSecBufferPtr buf, xmlSecSize size) {

   466     xmlSecAssert2(buf != NULL, -1);

   467 

   468     if(size < buf->size) {

   469 	buf->size -= size;

   470     } else {

   471 	buf->size = 0;

   472     }

   473     if(buf->size < buf->maxSize) {

   474 	xmlSecAssert2(buf->data != NULL, -1);

   475 	memset(buf->data + buf->size, 0, buf->maxSize - buf->size);

   476     }

   477     return(0);

   478 }

   479 

   480 /**

   481  * xmlSecBufferReadFile:

   482  * @buf:		the pointer to buffer object.

   483  * @filename:		the filename.

   484  *

   485  * Reads the content of the file @filename in the buffer.

   486  *

   487  * Returns 0 on success or a negative value if an error occurs.

   488  */

   489 EXPORT_C

   490 int 

   491 xmlSecBufferReadFile(xmlSecBufferPtr buf, const char* filename) {

   492     xmlSecByte buffer[1024];

   493     FILE* f;

   494     int ret, len;

   495 

   496     xmlSecAssert2(buf != NULL, -1);

   497     xmlSecAssert2(filename != NULL, -1);

   498 

   499     f = fopen(filename, "rb");

   500     if(f == NULL) {

   501 	xmlSecError(XMLSEC_ERRORS_HERE,

   502 		    NULL,

   503 		    "fopen",

   504 		    XMLSEC_ERRORS_R_IO_FAILED,

   505 		    "filename=%s;errno=%d", 

   506 		    xmlSecErrorsSafeString(filename),

   507 		    errno);

   508     if ( errno == ENOMEM )

   509         {

   510         xmlSecSetErrorFlag( -4 ); //KErrNoMemory

   511         }

   512 	return(-1);

   513     }

   514 

   515     while(1) {

   516         len = fread(buffer, 1, sizeof(buffer), f);

   517 	if(len == 0 && !errno) {

   518             break;

   519         }else if( errno ) {

   520             xmlSecError(XMLSEC_ERRORS_HERE,

   521                         NULL,

   522                         "fread",

   523                         XMLSEC_ERRORS_R_IO_FAILED,

   524                         "filename=%s;errno=%d", 

   525                         xmlSecErrorsSafeString(filename),

   526 			errno);

   527 			if ( errno == ENOMEM )

   528                 {

   529                 xmlSecSetErrorFlag( -4 ); //KErrNoMemory

   530                 }

   531             fclose(f);

   532             return(-1);

   533         }

   534 

   535 	ret = xmlSecBufferAppend(buf, buffer, len);

   536 	if(ret < 0) {

   537             xmlSecError(XMLSEC_ERRORS_HERE,

   538                         NULL,

   539                         "xmlSecBufferAppend",

   540                         XMLSEC_ERRORS_R_XMLSEC_FAILED,

   541                         "size=%d", 

   542                         len);

   543             fclose(f);

   544             return(-1);

   545         }     

   546     }

   547 

   548     fclose(f);

   549     return(0);

   550 }

   551 

   552 /**

   553  * xmlSecBufferBase64NodeContentRead:

   554  * @buf:		the pointer to buffer object.

   555  * @node:		the pointer to node.

   556  *

   557  * Reads the content of the @node, base64 decodes it and stores the

   558  * result in the buffer.

   559  *

   560  * Returns 0 on success or a negative value if an error occurs.

   561  */

   562 EXPORT_C

   563 int 

   564 xmlSecBufferBase64NodeContentRead(xmlSecBufferPtr buf, xmlNodePtr node) {

   565     xmlChar* content;

   566     xmlSecSize size;

   567     int ret;

   568     

   569     xmlSecAssert2(buf != NULL, -1);

   570     xmlSecAssert2(node != NULL, -1);

   571 

   572     content = xmlNodeGetContent(node);

   573     if(content == NULL) {

   574 	xmlSecError(XMLSEC_ERRORS_HERE,

   575 		    NULL,

   576 		    xmlSecErrorsSafeString(xmlSecNodeGetName(node)),

   577 		    XMLSEC_ERRORS_R_INVALID_NODE_CONTENT,

   578 		    XMLSEC_ERRORS_NO_MESSAGE);

   579 	return(-1);		

   580     }

   581     

   582     /* base64 decode size is less than input size */

   583     ret = xmlSecBufferSetMaxSize(buf, xmlStrlen(content));

   584     if(ret < 0) {

   585 	xmlSecError(XMLSEC_ERRORS_HERE,

   586 		    NULL,

   587 		    "xmlSecBufferSetMaxSize",

   588 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   589 		    XMLSEC_ERRORS_NO_MESSAGE);

   590 	xmlFree(content);

   591 	return(-1);

   592     }

   593     

   594     ret = xmlSecBase64Decode(content, xmlSecBufferGetData(buf), xmlSecBufferGetMaxSize(buf));

   595     if(ret < 0) {

   596 	xmlSecError(XMLSEC_ERRORS_HERE,

   597 		    NULL,

   598 		    "xmlSecBase64Decode",

   599 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   600 		    XMLSEC_ERRORS_NO_MESSAGE);

   601 	xmlFree(content);

   602 	return(-1);

   603     }

   604     size = ret;

   605 

   606     ret = xmlSecBufferSetSize(buf, size);

   607     if(ret < 0) {

   608 	xmlSecError(XMLSEC_ERRORS_HERE,

   609 		    NULL,

   610 		    "xmlSecBufferSetSize",

   611 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   612 		    "size=%d", size);

   613 	xmlFree(content);

   614 	return(-1);

   615     }

   616     xmlFree(content);

   617     

   618     return(0);

   619 }

   620 

   621 /**

   622  * xmlSecBufferBase64NodeContentWrite:

   623  * @buf:		the pointer to buffer object.

   624  * @node:		the pointer to a node.

   625  * @columns:		the max line size fro base64 encoded data.

   626  *

   627  * Sets the content of the @node to the base64 encoded buffer data.

   628  *

   629  * Returns 0 on success or a negative value if an error occurs.

   630  */

   631 EXPORT_C

   632 int 

   633 xmlSecBufferBase64NodeContentWrite(xmlSecBufferPtr buf, xmlNodePtr node, int columns) {

   634     xmlChar* content;

   635     

   636     xmlSecAssert2(buf != NULL, -1);

   637     xmlSecAssert2(node != NULL, -1);

   638 

   639     content = xmlSecBase64Encode(xmlSecBufferGetData(buf), xmlSecBufferGetSize(buf), columns);

   640     if(content == NULL) {

   641 	xmlSecError(XMLSEC_ERRORS_HERE,

   642 		    NULL,

   643 		    "xmlSecBase64Encode",

   644 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   645 		    XMLSEC_ERRORS_NO_MESSAGE);

   646 	return(-1);

   647     }

   648     xmlNodeAddContent(node, content);

   649     xmlFree(content);

   650     

   651     return(0);

   652 }

   653 

   654 /************************************************************************

   655  *

   656  * IO buffer

   657  *

   658  ************************************************************************/ 

   659 static int	xmlSecBufferIOWrite				(xmlSecBufferPtr buf,

   660 								 const xmlSecByte *data,

   661 								 xmlSecSize size);		

   662 static int	xmlSecBufferIOClose				(xmlSecBufferPtr buf);

   663 

   664 /**

   665  * xmlSecBufferCreateOutputBuffer:

   666  * @buf:		the pointer to buffer.

   667  *

   668  * Creates new LibXML output buffer to store data in the @buf. Caller is 

   669  * responsible for destroying @buf when processing is done. 

   670  *

   671  * Returns pointer to newly allocated output buffer or NULL if an error

   672  * occurs.

   673  */

   674 EXPORT_C

   675 xmlOutputBufferPtr 

   676 xmlSecBufferCreateOutputBuffer(xmlSecBufferPtr buf) {

   677     return(xmlOutputBufferCreateIO((xmlOutputWriteCallback)xmlSecBufferIOWrite,

   678 				     (xmlOutputCloseCallback)xmlSecBufferIOClose,

   679 				     buf,

   680 				     NULL)); 

   681 }

   682 

   683 static int 

   684 xmlSecBufferIOWrite(xmlSecBufferPtr buf, const xmlSecByte *data, xmlSecSize size) {

   685     int ret;

   686     

   687     xmlSecAssert2(buf != NULL, -1);

   688     xmlSecAssert2(data != NULL, -1);

   689     

   690     ret = xmlSecBufferAppend(buf, data, size);

   691     if(ret < 0) {

   692 	xmlSecError(XMLSEC_ERRORS_HERE,

   693 		    NULL,

   694 		    "xmlSecBufferAppend",

   695 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   696 		    "size=%d", size);

   697 	return(-1);

   698     }

   699     

   700     return(size);    

   701 }

   702 

   703 static int 

   704 xmlSecBufferIOClose(xmlSecBufferPtr buf) {

   705     xmlSecAssert2(buf != NULL, -1);

   706     

   707     /* just do nothing */

   708     return(0);

   709 }