securestorage_api.c

Go to the documentation of this file.

/******************************************************************************
 *
 *      File:                   securestorage_api.c
 *
 *      Function:               Secure Storage API source file
 *
 *      Author(s):              Giordano Scuderi and Nicola Dominante
 *
 *      Copyright:              Copyright (c) 2007 <Giordano Scuderi - gscuderi@unicosrl.it>
 *                                      All Rights Reserved.
 *
 *
 *      Notes:                  Redistributions of any form whatsoever must retain the following
 *                              acknowledgment:
 *                              "This product includes software developed by Giordano Scuderi
 *                              for Unico SRL"
 *
 * ====================================================================
 * Copyright (c) Giordano Scuderi, Unico SRL.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by Giordano Scuderi
 *    for Unico SRL"
 *
 * 4. The names "Secure Storage" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    gscuderi@unicosrl.it.
 *
 * 5. Products derived from this software may not be called "Secure Storage"
 *    nor may "Secure Storage" appear in their names without prior written
 *    permission of Giordano Scuderi (Unico SRL).
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by Giordano Scuderi
 *    for Unico SRL"
 *
 * THIS SOFTWARE IS PROVIDED BY UNICO SRL ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL UNICO SRL OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 * 
 */

#ifdef __cplusplus
extern "C"
{
#endif

#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <dirent.h>
#include <fcntl.h>
#include <time.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#if defined(_WIN32)
#include <io.h>
#else
#include <unistd.h>
#endif
#include <gfal_api.h>
#include "lcg_util.h"
#include "ss-util.h"
#include "keystore_client.h"
#include "securestorage.h"
#include "securestorage_api.h"

#ifdef __cplusplus
}
#endif

// Struct that contains some data of open file
static struct ss_state *ss_array[MAX_OPEN_FILES];

extern int serrno;
extern int errno;

/******************************************************************************
 * Alloc mem on ss_array struct and save file descriptor of open file on
 * remote SE
 * 
 ******************************************************************************/

static struct ss_state *alloc_ss_state (int fd) {
        if (fd >= 0 && fd < MAX_OPEN_FILES && ss_array[fd] == NULL)
               return (ss_array[fd] = (struct ss_state *) calloc (1, sizeof(struct ss_state)));
        errno = EBADF;
        return (NULL);
}


/******************************************************************************
 * Find correct position on ss_array struct with index (fd)
 *
 * 
 ******************************************************************************/

static struct ss_state *find_ss_state (int fd)
{
        if (fd >= 0 && fd < MAX_OPEN_FILES && ss_array[fd])
                return (ss_array[fd]);
        errno = EBADF;
        return (NULL);
}


/******************************************************************************
 * Free mem on ss_array struct
 *
 * 
 ******************************************************************************/

static int free_ss_state (int fd)
{
        if (fd >= 0 && fd < MAX_OPEN_FILES && ss_array[fd]) {
                free (ss_array[fd]);
                ss_array[fd] = NULL;
        }
        return (0);
}



/******************************************************************************
 * Open remote file on SE
 * extended version ( user could specify VO, GUID and destination SE
 * 
 ******************************************************************************/

int securestorage_open_extended(char *lfn, int flags, mode_t mode, 
                                                                        char *vo, char *guid, char *se) {
        
        // Variable definition
        struct ss_state *ss;
        unsigned char hex_key[HEX_KEYSIZE+1];
        unsigned char hex_iv[HEX_IVSIZE+1];
        char *dest_surl;
        char *lfn_new;
        char *conf_file=NULL;
        char actual_gid[37];
        int fd;
        const char *accept_host=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.-";
        const char *accept_vo=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789-";
        const char *accept_lfn=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.:_/-";
        size_t inv;
        int insecure=0;
        int verbose=0;
        
        memset(hex_key,'\0',HEX_KEYSIZE+1);
        memset(hex_iv,'\0',HEX_IVSIZE+1);
        
        // Verify if VO was specified
        if (!vo) {
                errno = SS_EINVALVO;
                return (-1);
        }
        // Verify if guid was specified
        if (guid) {
                if (strlen(guid)!=36 ) {
                        errno = SS_EINVALGUID;
                        return (-1);
                }
        }
        // Input parameters filter
        if (se){
                inv=0;
                inv = strspn(se, accept_host);
                if (inv != strlen(se) ) {
                        errno = SS_EINVALSE;
                        return (-1);
                }
        }
        inv=0;
        inv = strspn(vo, accept_vo);
        if (inv != strlen(vo) ) {
                errno = SS_EINVALVO;
                return (-1);
        }       
        // Add LFC_HOME to LFN
        if ( ss_get_lfchome(lfn, &lfn_new) < 0 ) {
                return (-1);
        }
        inv=0;
        inv = strspn(lfn_new, accept_lfn);
        if (inv != strlen(lfn_new) ) {
                free(lfn_new);
                errno = SS_EINVALLFN;
                return (-1);
        }
        // Generate SURL on file creation
        if ( (flags == (O_WRONLY|O_CREAT)) || (flags == (O_RDWR|O_CREAT)) ) {
                // Verify if Destination SE was specified
                if (!se) {
                        free(lfn_new);
                        errno = SS_EINVALSE;
                        return (-1);
                }
                int existence = ss_check_lfn ( lfn_new, vo);
                int errno_save = errno;
                if ( existence < 0 ) {
                        free(lfn_new);
                        errno = errno_save;
                        return (-1);
                } else if ( existence == 1 ) {
                        free(lfn_new);
                        errno = SS_EEXIST;
                        return (-1);
                }
                
                if ( ss_generate_surl(&dest_surl, se, vo, guid) < 0 ) {
                        int errno_save = errno;
                        free(lfn_new);
                        errno = errno_save;     
                        return (-1);    
                }
        } 
        else if ( ss_get_surl(lfn_new,&dest_surl,vo,se,0) < 0 ) { // Get the replica SURL
                        // No replica found or an error occured
                        int errno_save = errno;
                        free(lfn_new);
                        errno = errno_save;
                        return (-1);
        }

    // Open remote file
    if ((fd = gfal_open (dest_surl, flags, mode)) < 0) {
                int errno_save = errno;
                free(lfn_new); free(dest_surl);
                errno = errno_save;
                return (-1);
        } else if ((ss = alloc_ss_state(fd)) == NULL) { // Alloc mem space for struct
                int errno_save = errno;
                free(lfn_new); free(dest_surl);
                errno = errno_save;
                return (-1);    
        } else {
                ss->fd = fd; // Save file descriptor
        }
        
        if ( (flags == (O_WRONLY|O_CREAT)) || (flags == (O_RDWR|O_CREAT)) ) {
                // Register file into catalog
                if (lcg_rf(dest_surl, guid, lfn_new, vo, conf_file, insecure, verbose, actual_gid) < 0 ) { 
                        int errno_save = errno;
                        gfal_close(fd);
                        // Delete orphaned file from storage element
                        int aflag=0;
                        lcg_delt (dest_surl, aflag, se, vo, conf_file, insecure, verbose, 0);
                        free(lfn_new); free(dest_surl);
                        errno = errno_save;
                        return (-1);
                }
        }
        
        // New file creation -> create new encryption key
        if ( (flags == (O_WRONLY|O_CREAT)) || (flags == (O_RDWR|O_CREAT)) ) {
                /*********************  GENERATE KEY AND IV  ***************************/

                if ( ss_rand (HEX_KEYSIZE, hex_key) < 0 ) {
                        return (-1);
                }
                if ( ss_rand (HEX_IVSIZE, hex_iv ) < 0 ) {
                        return (-1);
                }
                
                //SAVE KEY AND IV TO KEYSTORE
                if ( ss_send_key (lfn_new, hex_key, hex_iv) < 0 ) {
                        int errno_save = errno;
                        gfal_close(fd);
                        // Delete orphaned file from storage element
                        int aflag=0;
                        lcg_delt (dest_surl, aflag, se, vo, conf_file, insecure, verbose, 0);
                        free(lfn_new); free(dest_surl);
                        errno = errno_save;
                        return (-1);
                }

                free(lfn_new); 
        } 
        // To read or write file that exist, read old encrytion key
        else if ( (flags == O_WRONLY) || (flags == O_RDONLY) || (flags == O_RDWR) ) {
                
                if ( ss_get_key (lfn_new, hex_key, hex_iv) < 0 ) {
                        int errno_save = errno;
                        free(lfn_new); free(dest_surl);
                        errno = errno_save;
                        return (-1);
                }
                free(lfn_new);
        }
        
        // Set encrypt key
        if ( AES_set_encrypt_key(hex_key, 256, &ss->ctx) < 0 ) {
                free(dest_surl); 
                errno = SS_EENCINIT;
                return (-1);
        }
        // Clear KEY
        memset(hex_key, 0, HEX_KEYSIZE);
        // Set Initialization vector to ss struct
        memcpy(ss->hex_iv, hex_iv, HEX_IVSIZE);
        memcpy(ss->ivec, hex_iv, HEX_IVSIZE);
        // Clear IV
        memset(hex_iv, 0, HEX_IVSIZE);
        // Initialize ecount_buf and num for aes_ctr encryption/decryption
        memset(ss->ecount_buf, 0, AES_BLOCK_SIZE);
        // Initialize num for AES encryption
        ss->num = 0;
        free(dest_surl);
        return fd;
}

/******************************************************************************
 * Open remote file on specified SE
 *
 * 
 ******************************************************************************/

int securestorage_open_se (char *lfn, int flags, mode_t mode, char *se) {
        
        int fd;
        char *guid=NULL;
        char *vo;
        
        if (lfn == NULL) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        // Get default VO from Environment Variable
        vo = getenv(VO);
        if (!vo) {
                errno = SS_EINVALVO;
                return (-1);
        }
        // Input parameters filter
        if (!se) {
                errno = SS_EINVALSE;
                return (-1);
        }
        // Call open_extended with specified SE and default VO
        if ((fd = securestorage_open_extended(lfn,flags,mode,vo,guid,se)) < 0 ){
                return (-1);
        }
        return fd;
}




/******************************************************************************
 * Open remote file on default SE
 *
 * 
 ******************************************************************************/

int securestorage_open( char *lfn, int flags, mode_t mode ) {
        
        int fd, i;
        char *guid=NULL;
        char *storageelementdest, *vo, *se;
        
        if (lfn == NULL) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        // Get default VO from Environment Variable
        vo = getenv(VO);
        if (!vo) {
                errno = SS_EINVALVO;
                return (-1);
        }
        // Get default SE from Environment Variable
        char oo[strlen(vo)+1];
        strcpy(oo,vo);
        for (i=0; oo[i]!=0; i++)
                oo[i] = toupper(oo[i]);
        storageelementdest = calloc(1, (strlen(oo)+strlen("VO_%s_DEFAULT_SE")+1));
        sprintf(storageelementdest,"VO_%s_DEFAULT_SE",oo);
        se = getenv(storageelementdest);
        if (!se) {
                free(storageelementdest);
                errno = SS_EINVALSE;
                return (-1);
        }
        if ( (fd = securestorage_open_extended(lfn, flags, mode, vo, guid, se) ) < 0 ) {
                int errno_save = errno;
                free(storageelementdest);
                errno = errno_save;
                return (-1);
        }
        free(storageelementdest);

        return fd;
}



/******************************************************************************
 * Close remote file
 *
 * 
 ******************************************************************************/

int securestorage_close (int fd) {
        
        // Variable definition
        struct ss_state *ss;
        if ( (ss=find_ss_state(fd)) == NULL ) {
                return (-1);
        }
        if (gfal_close(fd) < 0) {
                int errno_save = errno;
                free_ss_state(fd);
                errno = errno_save;
                return (-1);
        }
        free_ss_state(fd);
        
        return 0;       
}



/******************************************************************************
 * Encrypt and Write a file on remote SE
 * writing must be finalized with write_final
 * 
 ******************************************************************************/

int securestorage_write (int fd, void *buffer, size_t size ) {
        
        // Variable definition
        struct ss_state *ss;
        unsigned char *data, *out;
        int cod_ex=0;
        size_t len = size;
        
        // Get ss struct
        if ( (ss=find_ss_state(fd)) == NULL ) {
                return (-1);
        }
        data=buffer;
        out = calloc(1, size+1);
        
        //Do encryption
        securestorage_AES_ctr(data, out, len, &ss->ctx, ss->ivec, ss->ecount_buf, &(ss->num));
        
        if ((cod_ex = gfal_write(fd, out, len)) < 0 ) {
                int errno_save = errno;
                free(out);
                errno = errno_save;
                return (-1); 
        } else if ( cod_ex != len ) {
                free(out);
                errno = EIO;
                return (-1); 
        }
        free(out);
        
        return len;     
}


/******************************************************************************
 * Read and decrypt a file from remote SE
 * read must be finalized with read_final
 * 
 ******************************************************************************/

int securestorage_read ( int fd, void *buffer, size_t size ) {
        
        // Variable definition
        struct ss_state *ss;
        unsigned char *data;
        unsigned char *in = calloc (1, size+1);
        size_t len = 0;
        data=buffer;
        
        if ( (ss=find_ss_state(fd)) == NULL ) {
                int errno_save = errno;
                free(in);
                errno = errno_save;
                return (-1);
        }
        
        // Read source file
        if ((len = gfal_read (fd, in, size)) != size) {
                if (len < 0) {
                        int errno_save = errno;
                        free(in);
                        errno = errno_save;
                        return (-1);
                }
        }
        
        //Do encryption
        securestorage_AES_ctr(in, data, len, &ss->ctx, ss->ivec, ss->ecount_buf, &(ss->num));
        
        free(in);
        
        return len;
}


/******************************************************************************
 * Seek
 *
 * 
 ******************************************************************************/
off_t securestorage_lseek (int fd, off_t offset, int whence) {
        
        // Variable definition
        struct ss_state *ss;
        off_t curr_position, old_position, file_size;
        int n, old_block_count, curr_block_count, shift, write_bytes;
        unsigned char *buffer;
        
        if ( (ss=find_ss_state(fd)) == NULL ) {
                return (-1);
        }
        
        // Verify if whence was specified correctly
        if ( whence != SEEK_CUR && whence != SEEK_SET && whence != SEEK_END ) {
                errno = SS_EWHENCE;
                return (-1);
        } else if ( whence == SEEK_SET && offset < 0 ) {
                errno = SS_ESPIPE;
                return (-1);
        } 
        
        if ( whence == SEEK_END && offset > 0 ) { // Add offset to current file_size
                if ( (curr_position = securestorage_lseek ( fd, 0, SEEK_END)) < 0 ) {
                        return (-1);
                }
                buffer = calloc(1, offset);
                write_bytes = 0;
                if ( (write_bytes = securestorage_write( fd, buffer, offset )) < 0 ) {
                        int errno_save = errno;
                        free(buffer);
                        errno = errno_save;
                        return (-1);
                }
                curr_position +=  write_bytes;
                free(buffer);
                return curr_position;   
        } 
        
        // Save old position
        if ( (old_position = gfal_lseek ( fd, 0, SEEK_CUR)) < 0 ) {
                errno = SS_ESPIPE;
                return (-1);
        }

        if ( whence==SEEK_CUR && offset==0 ) {
                return old_position;
        } 
        
        // Workaround to SEEK_END with a negative offset
        if ( whence == SEEK_END && offset < 0 ) {
                // Positioning at end of the file
                if ( (curr_position = gfal_lseek ( fd, 0, SEEK_END)) < 0 ) {
                        return (-1);
                }
                if ( -offset > curr_position ) {
                        errno = SS_EOFFSET;
                        return (-1);
                }
                // Moving to negative offset specified using SEEK_CUR ( with SEEK_END it doesn't work )
                if ( (curr_position = gfal_lseek ( fd, offset, SEEK_CUR)) < 0 ) {
                        return (-1);
                }
        // Verify if offset go out of file from beginning
        } else if ( -offset > old_position ) {
                errno = SS_EOFFSET;
                return (-1);
        // Normal SEEK offset > 0
        } else if ( offset > 0 ) {
                if ( (file_size = securestorage_lseek ( fd, 0, SEEK_END)) < 0 ) {
                        return (-1);
                }
                off_t offset_new = (old_position + offset) - file_size;
                
                if ( offset_new == 0 ) {
                        return file_size;
                } else if ( offset_new > 0 ) {
                        buffer = calloc(1, offset_new);
                        write_bytes = 0;
                        if ( (write_bytes = securestorage_write( fd, buffer, offset_new )) < 0 ) {
                                int errno_save = errno;
                                free(buffer);
                                errno = errno_save;
                                return (-1);
                        }
                        file_size +=  write_bytes;
                        free(buffer);
                        return file_size;
                } else {
                        old_position = file_size;
                        if ( (curr_position = gfal_lseek ( fd, offset_new, SEEK_CUR)) < 0 ) {
                                return (-1);
                        }
                }
        // Normal SEEK offset < 0
        } else if ( (curr_position = gfal_lseek ( fd, offset, whence)) < 0 ) {
                errno = SS_EOFFSET;
                return (-1);
        }
        // Calculating local-block position
        ss->num = curr_position % AES_BLOCK_SIZE;
        //Calculating wide-block position
        old_block_count = (int) old_position / AES_BLOCK_SIZE;
        curr_block_count = (int) curr_position /AES_BLOCK_SIZE;
        //Calculating increase or decrease count for ivec
        shift = (( curr_block_count - old_block_count) -1 );
        
        if ( old_position == 0 ) {
                AES_encrypt(ss->ivec, ss->ecount_buf, &ss->ctx);
                ivec_inc(ss->ivec);
        }
        
        if ( curr_block_count == old_block_count ) {
                if(!ss->num)
                        ivec_dec(ss->ivec);
        } else {
                if ( curr_block_count > old_block_count ) {
                        // Increase ivec
                        for (n=shift;n>0;n--)
                                ivec_inc(ss->ivec);
                } else if ( curr_block_count < old_block_count ) {
                        // Decrease ivec
                        for (n=shift;n<0;n++)
                                ivec_dec(ss->ivec);
                } else if ( curr_block_count == 0 ) {
                        // Begin of the file -> initial ivec
                        memcpy(ss->ivec, ss->hex_iv, HEX_IVSIZE);
                }
                // Prepare encrypted ecount_buf for read or write functions
                if(ss->num) {
                        AES_encrypt(ss->ivec, ss->ecount_buf, &ss->ctx);
                        ivec_inc(ss->ivec);
                }
        }
        
        return curr_position;
}


/******************************************************************************
 * Delete remote file (one replica or all replica) and associated Key from SE
 * extended (user could specify vo, conf_file, insecure,verbose and timeout
 * 
 ******************************************************************************/

int securestorage_del_extended (char *lfn,int aflag,char *se,char *vo,
                                                char *conf_file,int insecure,int verbose,int timeout) {
        
        int deletekey=0;
        int x;
        size_t inv;
        char *src_file_new;
        // Valid character
        const char *accept_host=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.-";
        const char *accept_vo=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789-";
        const char *accept_lfn=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.:_/-";

        if (lfn==NULL) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        // Verify length of destination lfn
        if (strlen (lfn) + 1 > LCG_MAXPATHLEN) {
                errno = SS_ENAMETOOLONG;
                return (-1);
        }
        if (vo == NULL) {
                vo = getenv(VO);
                if (!vo) {
                        errno = SS_EINVALVO;
                        return (-1);
                }
        }
        // Input file must be an LFN
        if (strncmp(lfn, "lfn:", 4) != 0) {
                errno = SS_EINVALLFN;
                return (-1);    
        }
        
        if ( aflag ==0 && se == NULL) {
                errno = SS_EINVALSE;
                return (-1);    
        }
        
        // Input parameters filter
        inv=0;
        inv = strspn(vo, accept_vo);
        if (inv != strlen(vo) ) {
                errno = SS_EINVALVO;
                return (-1);
        }
        inv=0;
        inv = strspn(lfn, accept_lfn);
        if (inv != strlen(lfn) ) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        if (se != NULL) {
                inv=0;
                inv = strspn(se, accept_host);
                if (inv != strlen(se) ) {
                        errno = SS_EINVALSE;
                        return (-1);
                }
        }       
        // Add LFC_HOME to LFN
        if ( ss_get_lfchome(lfn, &src_file_new) < 0 ) {
                int errno_save = errno;
                errno = errno_save;
                return (-1);                    
        }
        
        int existence = ss_check_lfn ( src_file_new, vo);
        int errno_save = errno;
        if ( existence < 0 ) {
                free(src_file_new);
                errno = errno_save;
                return (-1);
        } else if ( existence == 0 ) {
                free(src_file_new);
                errno = SS_ENOENT;
                return (-1);
        }
        
        if (aflag == 0) {
        char **pfns;
                if ( lcg_lr(src_file_new, vo, conf_file, insecure, &pfns) < 0) {
                        int errno_save = errno;
                        free(src_file_new);
                        errno = errno_save;
                        return (-1);
                }
                // Verify if exist at least one replica
                if (pfns[0] == NULL) {
                        free(pfns); free(src_file_new);
                        errno = SS_ENOENT;
                        return (-1);
                } else if (pfns[1] == NULL) {
                        pfns[0]+=6;
                        int g = strcspn(se, "\n");
                        if (strncmp (pfns[0], se, g) != 0) {
                                pfns[0]-=6;
                                free(pfns[0]); free(pfns); free(src_file_new);
                                errno = SS_ENOREPLICA;
                                return (-1);
                        }
                        deletekey=1;
                        pfns[0]-=6;
                } else {
                        int found = 0;
                        for (x=0;pfns[x]!=NULL;x++) {
                                pfns[x]+=6;
                                int g = strcspn(se, "\n");
                                if (strncmp (pfns[x], se, g) == 0) {
                                        found = 1;
                                        pfns[x]-=6;
                                        break;
                                }
                                pfns[x]-=6;
                        }
                        if (!found) {
                                for(x=0;pfns[x]!=NULL;x++) {
                                        free(pfns[x]);
                                }
                                free(pfns); free(src_file_new);
                                errno = SS_ENOREPLICA;
                                return (-1);
                        }
                        
                }               
                
        }
        if ( aflag == 1 || deletekey == 1) {
                
                // DELETE KEY AND IV FROM KEYSTORE
                if ( ss_delete_key(src_file_new) < 0) {
                        int errno_save = errno;
                        free(src_file_new);
                        errno = errno_save;
                        return (-1);
                }       
    }
    
        if (lcg_delt (src_file_new, aflag, se, vo, conf_file, insecure, verbose, timeout) < 0) {
                int errno_save = errno;
                free(src_file_new);
                errno = errno_save;
                return (-1);
        }
        
        free(src_file_new);
        
        return 0;
}


/******************************************************************************
 * Delete remote file (one replica or all replica) and associated Key from SE
 *
 * 
 ******************************************************************************/

int securestorage_del ( char *lfn, int aflag, char *se ) {

        char *vo;
        char *storageelementdest;
        int i=0;
        int insecure=0;
        int verbose=0;
        int timeout=0;
        char *conf_file=NULL;
        
        vo = getenv(VO);
        if (!vo) {
                errno = SS_EINVALVO;
                return (-1);
        }
        
        if (!se){
                // Get default SE from Environment Variable
                char oo[strlen(vo)+1];
                strcpy(oo,vo);
                for (i=0; oo[i]!=0; i++)
                        oo[i] = toupper(oo[i]);
                storageelementdest = calloc(1, (strlen(oo)+strlen("VO_%s_DEFAULT_SE")+1));
                sprintf(storageelementdest,"VO_%s_DEFAULT_SE",oo);
                se = getenv(storageelementdest);
                free(storageelementdest);
                if (!se) {
                        errno = SS_EINVALSE;
                        return (-1);
                }               
        }
        
        if ( securestorage_del_extended(lfn,aflag,se,vo,conf_file,insecure,verbose,timeout) < 0 ){
                return (-1);
        }
        
        return 0;
}


/******************************************************************************
 * Open directory path specified
 *
 * 
 ******************************************************************************/

ss_DIR *securestorage_opendir (const char *name) {
        
        ss_DIR *dp;
        const char *accept_host=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.-";
        const char *accept_lfn=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.:_/-";
        size_t inv;
        char *name_new;
        
        if (!name) {
                errno = SS_EINVALLFN;
                return NULL;
        }
        char *lfc_host;
        lfc_host = getenv("LFC_HOST");
        if (lfc_host == NULL) {
                errno = SS_EINVAL;
                return NULL;
        }
        // Input parameters filter
        inv=0;
        inv = strspn(lfc_host, accept_host);
        if (inv != strlen(lfc_host) ) {
                errno = SS_EINVAL;
                return NULL;
        }
        // Add LFC_HOME to LFN
        if ( ss_get_lfchome(name, &name_new) < 0 ) {
                return NULL;
        }
        inv=0;
        inv = strspn(name_new, accept_lfn);
        if (inv != strlen(name_new) ) {
                free(name_new);
                errno = SS_EINVALLFN;
                return NULL;
        }       
        
        char *input_lfn_tmp = name_new;
        if (strncmp (input_lfn_tmp, "lfn:", 4) == 0) {
                        input_lfn_tmp += 4;
        }
        
        if ( (dp = lfc_opendirxg(lfc_host,input_lfn_tmp,NULL)) == NULL ) {
                int errno_save = serrno;
                free(name_new);
                errno = errno_save;
                return NULL;
        }
        
        free(name_new);
        return dp;
}

/******************************************************************************
 * List file/directory entry on specified path
 *
 * 
 ******************************************************************************/

struct dirent *securestorage_readdir (ss_DIR *dp) {
        
        struct dirent *ep;
        
        if (!dp) {
                errno = SS_EINVAL;
                return NULL;
        }
        
        if ( (ep = lfc_readdir(dp)) == NULL ) {
                int errno_save = serrno;
                errno = errno_save;
                return NULL;
        }
        
        return ep;
}

/******************************************************************************
 * Close directory 
 *
 * 
 ******************************************************************************/

int securestorage_closedir (ss_DIR *dp) {
        
        if (!dp) {
                errno = SS_EINVAL;
                return (-1);
        }
        
        if ( lfc_closedir(dp) < 0 ) {
                int errno_save = serrno;
                errno = errno_save;
                return (-1);
        }
        
        return (0);
}


/******************************************************************************
 * Make directory 
 *
 * 
 ******************************************************************************/

int securestorage_mkdir (const char *path, mode_t mode) {
        
        const char *accept_lfn=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.:_/-";
        size_t inv;
        char *path_new;
        
        if (!path) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        if (!mode) {
                errno = SS_EINVAL;
                return (-1);
        }
        // Add LFC_HOME to LFN
        if ( ss_get_lfchome(path, &path_new) < 0 ) {
                return (-1);
        }
        inv=0;
        inv = strspn(path_new, accept_lfn);
        if (inv != strlen(path_new) ) {
                free(path_new);
                errno = SS_EINVALLFN;
                return (-1);
        }       
        
        char *input_lfn_tmp = path_new;
        if (strncmp (input_lfn_tmp, "lfn:", 4) == 0) {
                        input_lfn_tmp += 4;
        }
        
        if ( lfc_mkdir(input_lfn_tmp, mode) < 0 ) {
                int errno_save = serrno;
                free(path_new);
                errno = errno_save;
                return (-1);
        }
        free(path_new);
        return (0);
}

/******************************************************************************
 * Remove directory 
 *
 * 
 ******************************************************************************/

int securestorage_rmdir (const char *path) {
        
        const char *accept_lfn=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.:_/-";
        size_t inv;
        char *path_new;
        
        if (!path) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        // Add LFC_HOME to LFN
        if ( ss_get_lfchome(path, &path_new) < 0 ) {
                return (-1);
        }
        inv=0;
        inv = strspn(path_new, accept_lfn);
        if (inv != strlen(path_new) ) {
                free(path_new);
                errno = SS_EINVALLFN;
                return (-1);
        }       
        
        char *input_lfn_tmp = path_new;
        if (strncmp (input_lfn_tmp, "lfn:", 4) == 0) {
                        input_lfn_tmp += 4;
        }
        
        if ( lfc_rmdir(input_lfn_tmp) < 0 ) {
                int errno_save = serrno;
                free(path_new);
                errno = errno_save;
                return (-1);
        }
        
        free(path_new);
        return (0);
}


/******************************************************************************
 * Get information about a LFC file or directory from LCG File Catalog
 *
 * 
 ******************************************************************************/

int securestorage_statg (const char *path, const char *guid, 
                                                                struct ss_filestatg *statbuf) {
        
        const char *accept_lfn=" abcdefghilmnopqrstuvzwyxkjABCDEFGHILMNOPQRSTUVZWYXKJ0123456789.:_/-";
        size_t inv;
        char *path_new;
        
        if (!path || !statbuf) {
                errno = SS_EINVALLFN;
                return (-1);
        }
        // Add LFC_HOME to LFN
        if ( ss_get_lfchome(path, &path_new) < 0 ) {
                return (-1);
        }
        inv=0;
        inv = strspn(path_new, accept_lfn);
        if (inv != strlen(path_new) ) {
                free(path_new);
                errno = SS_EINVALLFN;
                return (-1);
        }       
        
        char *input_lfn_tmp = path_new;
        if (strncmp (input_lfn_tmp, "lfn:", 4) == 0) {
                        input_lfn_tmp += 4;
        }
        
        if ( lfc_statg(input_lfn_tmp, guid, statbuf) < 0 ) {
                int errno_save = serrno;
                free(path_new);
                errno = errno_save;
                return (-1);
        }
        
        free(path_new);
        return (0);
        
}

---