News. - What is DAR? - The bindings. - API Documentation. - Related works. - Project site. - What is the logo? - Public key.

           

---

libdrc.c

Go to the documentation of this file.

/*
 * libdrc.c
 * Created on 14 Mar 2005
 * Authors:
 *    Wesley Leggette <wleggette@kaylix.net>
 * 
 * 
 * 
 * libdarc
 * 
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * $Id: libdrc_8c-source.html 708 2005-03-21 12:30:37Z leggwes $
 */

#include "libdrc.h"

#if HAVE_ERRNO_H
#include <errno.h>
#endif

#if HAVE_STDLIB_H
#include <stdlib.h>
#endif


#include <libxml/parser.h>
#include <libxml/tree.h>


/* internal tool functions */

static char* bool_to_string( bool val ); /* returns null on error */
static bool string_to_bool( char* str, bool* val ); /* returns false on error */
static char* allocate_copy_string( const char* source ); /* null indicates no mem */



struct _dar_drc
{
    enum { read_file, read_memory } read_mode;
    
    char* xml_buffer;
    char* xml_filename;
    
    int xml_buffer_size;
    
    char* dtd_filename;
    int dtd_version;
    
    xmlDocPtr doc;
    
    
    dar_sup_spec* spec;
    dar_sup_storage* storage;
    dar_sup_flags* flags;
    
    bool has_reference;
    
    dar_sup_spec* ref_spec;
    dar_sup_storage* ref_storage;
    dar_sup_flags* ref_flags;
    
    
};
    





/* internal process division functions */

static char* get_dtd_location(const char* dtdfilepath, const char* version);
static void validate_drc(dar_drc* ref, dar_sup_exception* exception);
static void interpret_drc(dar_drc* ref, dar_sup_exception* exception);
static bool dar_drc_prep(dar_drc* ref); /* null pointers and set defaults */
static xmlNodePtr get_next_element_node(xmlNodePtr node);


/* interpreters */

static void interpret_drc_1_0(dar_drc* ref, dar_sup_exception* exception);
    

/* library functions */

char* dar_drc_get_passphrase( dar_drc* ref )
{
    DEBUG("Function: dar_drc_get_passphrase: Retrieving passphrase.\n");
    if (ref->storage->crypto_pass == NULL)
        return NULL;
    char* ret = (char*)malloc(strlen(ref->storage->crypto_pass) + 1);
    if (ret == NULL) { return NULL; }
    strcpy( ret, ref->storage->crypto_pass );
    return ret;
}

bool dar_drc_set_passphrase( dar_drc* ref, char* passphrase )
{
    DEBUG("Function: dar_drc_set_passphrase: Replacing passphrase.\n");
    char* tmp = ref->storage->crypto_pass;
    ref->storage->crypto_pass = (char*)malloc(strlen(passphrase) + 1);
    if (ref->storage->crypto_pass == NULL)
    {
        ref->storage->crypto_pass = tmp;
        return false;
    }
    strcpy( ref->storage->crypto_pass, passphrase );
    if (tmp != NULL)
        free(tmp);
    return true;
}

char* dar_drc_get_reference_passphrase( dar_drc* ref )
{
    DEBUG("Function: dar_drc_get_reference_passphrase: Retrieving reference archive passphrase.\n");
    if (ref->ref_storage->crypto_pass == NULL)
        return NULL;
    char* ret = (char*)malloc(strlen(ref->ref_storage->crypto_pass) + 1);
    if (ret == NULL) { return NULL; }
    strcpy( ret, ref->ref_storage->crypto_pass );
    return ret;
}

bool dar_drc_set_reference_passphrase( dar_drc* ref, char* passphrase )
{
    DEBUG("Function: dar_drc_set_reference_passphrase: Replacing reference archive passphrase.\n");
    char* tmp = ref->ref_storage->crypto_pass;
    ref->ref_storage->crypto_pass = (char*)malloc(strlen(passphrase) + 1);
    if (ref->ref_storage->crypto_pass == NULL)
    {
        ref->ref_storage->crypto_pass = tmp;
        return false;
    }
    strcpy( ref->ref_storage->crypto_pass, passphrase );
    if (tmp != NULL)
        free(tmp);
    return true;
}

bool dar_drc_has_reference(dar_drc* ref)
{
    DEBUG("Function: dar_drc_has_reference: Querying if drc contains reference archive specs.\n");
    return ref->has_reference;
}

dar_archive* dar_drc_open_reference( dar_user_interaction_struct dialog,
                dar_drc* ref, dar_sup_exception* exception )
{
    DEBUG("Function: dar_drc_open_reference: Opening reference archive.\n");

    if (ref->has_reference)
    {
        DEBUG("Reference archive exists, opening.\n");
        dar_archive* ret = dar_op_archive_open( dialog, *(ref->ref_spec),
                                        *(ref->ref_storage), exception );
                                        
        if ( exception->type != LIBDAR_NOEXCEPT )
        {
            DEBUG("Exception caught, throwing.\n");
            return NULL;
        }
        return ret;
    } else {
        DEBUG("No reference archive exists, returning null.\n");
        return NULL;
    }
}


dar_sup_spec *dar_drc_get_spec( dar_drc* ref )
{
    DEBUG("Function: dar_drc_get_spec: Retrieving archive spec struct.\n");
    return ref->spec;
}

dar_sup_storage *dar_drc_get_storage( dar_drc* ref )
{
    DEBUG("Function: dar_drc_get_storage: Retrieving archive storage struct.\n");
    return ref->storage;
}

dar_sup_flags *dar_drc_get_flags( dar_drc* ref )
{
    DEBUG("Function: dar_drc_get_flags: Retrieving archive flags struct.\n");
    return ref->flags;
}

void dar_drc_destroy( dar_drc *ref )
{
    DEBUG("Function: dar_drc_destroy: Freeing drc context object.\n");
    if ( ref->doc != NULL )
        xmlFreeDoc(ref->doc);
    if ( ref->dtd_filename != NULL )
        free(ref->dtd_filename);
    if ( ref->xml_buffer != NULL )
    {
        free(ref->xml_buffer);
    }
    if ( ref->xml_filename != NULL )
    {
        free(ref->xml_filename);
    }
    if ( ref->flags != NULL )
    {
        free(ref->flags);
    }
    if ( ref->spec != NULL )
    {
        dar_sup_spec_destroy(ref->spec);
        free(ref->spec);
    }
    if ( ref->storage != NULL )
    {
        dar_sup_storage_destroy(ref->storage);
        free(ref->storage);
    }
    if ( ref->ref_spec != NULL )
    {
        dar_sup_spec_destroy(ref->ref_spec);
        free(ref->ref_spec);
    }
    if ( ref->ref_storage != NULL )
    {
        dar_sup_storage_destroy(ref->ref_storage);
        free(ref->ref_storage);
    }
    if ( ref->ref_flags != NULL )
    {
        free(ref->ref_flags);
    }
    
    free(ref);
    
    return;
}

dar_drc *dar_drc_create( dar_drc* reference,
                dar_sup_spec* spec, dar_sup_storage* storage,
                dar_sup_flags* flags )
{
    DEBUG("Function: dar_drc_create: Creating drc from archive spec structures.\n");
    dar_drc* ret = (dar_drc*)malloc(sizeof(dar_drc));
    if (ret == NULL)
    {
        DEBUG("Memory exhausted, could not allocate drc context object.\n");
        return NULL;
    }
    
    DEBUG("Preping drc context.\n");
    
    if ( !dar_drc_prep(ret) )
    {
        DEBUG("Memory exhausted, could not allocate drc internal storage.\n");
        free(ret);
        return NULL;
    }
        
    DEBUG("Copying reference archive specification if applicable.\n");
    
    if (reference != NULL)
    {
        DEBUG("Copying reference archive elements: spec structure.\n");
        
        if (reference->spec->arc_path != NULL)
        {
            ret->ref_spec->arc_path = 
                    allocate_copy_string(reference->spec->arc_path);
            if ( ret->ref_spec->arc_path == NULL )
            {
                DEBUG("Memory exhausted, could not allocate archive path copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        if (reference->spec->arc_name != NULL)
        {
            ret->ref_spec->arc_name =
                    allocate_copy_string(reference->spec->arc_name);
            if ( ret->ref_spec->arc_name == NULL )
            {
                DEBUG("Memory exhausted, could not allocate archive name copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        if (reference->spec->arc_ext != NULL)
        {
            ret->ref_spec->arc_ext =
                    allocate_copy_string(reference->spec->arc_ext);
            if ( ret->ref_spec->arc_ext == NULL )
            {
                DEBUG("Memory exhausted, could not allocate archive extension copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        if (reference->spec->input_pipe != NULL)
        {
            ret->ref_spec->input_pipe =
                    allocate_copy_string(reference->spec->input_pipe);
            if ( ret->ref_spec->input_pipe == NULL )
            {
                DEBUG("Memory exhausted, could not allocate input pipe name copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        if (reference->spec->output_pipe != NULL)
        {
            ret->ref_spec->output_pipe =
                    allocate_copy_string(reference->spec->output_pipe);
            if ( ret->ref_spec->output_pipe == NULL )
            {
                DEBUG("Memory exhausted, could not allocate output pipe name copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        DEBUG("Copying reference archive elements: storage structure.\n");
        
        ret->ref_storage->crypto_algo =
                reference->storage->crypto_algo;
                
        ret->ref_storage->crypto_size =
                reference->storage->crypto_size;
        
        if (reference->storage->crypto_pass != NULL)
        {
            ret->ref_storage->crypto_pass =
                    allocate_copy_string(reference->storage->crypto_pass);
            if ( ret->ref_storage->crypto_pass == NULL )
            {
                DEBUG("Memory exhausted, could not allocate passphrase copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        if (reference->storage->slice_execute != NULL)
        {
            ret->ref_storage->slice_execute =
                    allocate_copy_string(reference->storage->slice_execute);
            if ( ret->ref_storage->slice_execute == NULL )
            {
                DEBUG("Memory exhausted, could not allocate interslice command copy.\n");
                dar_drc_destroy(ret);
                return NULL;
            }
        }
        
        DEBUG("Finished copying reference archive elements.\n");
    }
    
    DEBUG("Inserting archive specification structures.\n");
    
    ret->spec = spec;
    ret->storage = storage;
    ret->flags = flags;
    
    return ret; 
}

bool dar_drc_write_xml_file( const char* filename,
                dar_sup_exception* exception )
{
    DEBUG("Function: dar_drc_write_xml_file: Writing drc to file.\n");
    /* TODO: Implement this function */
    LIBDARC_EXCEPTION(exception, LIBDAR_ELIBCALL,
        "Library call not yet implemented.");
    return false;
    
}

char* dar_drc_write_xml_buffer( dar_sup_exception* exception )
{
    DEBUG("Function: dar_drc_write_xml_buffer: Writing drc to memory.\n");
    /* TODO: Implement this function */
    LIBDARC_EXCEPTION(exception, LIBDAR_ELIBCALL,
        "Library call not yet implemented.");
    return NULL;
}

dar_drc *dar_drc_parse_xml_memory( const char* buffer, int size,
                const char* dtdfilepath, dar_sup_exception* exception )
{
    exception->type = LIBDAR_NOEXCEPT;
    
    DEBUG("Function: dar_drc_parse_xml_memory: Building drc from memory.\n");
    dar_drc* ret = (dar_drc*)malloc(sizeof(dar_drc));
    if (ret == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate drc context object.");
        return NULL;
    }
    
    DEBUG("Prepring drc content.\n");
    
    if ( !dar_drc_prep(ret) )
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate drc internal storage.");
        free(ret);
        return NULL;
    }
    
    ret->read_mode = read_memory;
    ret->xml_buffer = (char*)malloc(size);
    if (ret->xml_buffer == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate xml buffer copy.");
        dar_drc_destroy(ret);
        return NULL;
    }
    memcpy( ret->xml_buffer, buffer, size );
    ret->xml_buffer_size = size;
    
    ret->doc = xmlReadMemory(ret->xml_buffer, size, NULL, NULL, 0);
    if (ret->doc == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Failed to parse xml file.");
        dar_drc_destroy(ret);
        return NULL;
    }
    
    if (dtdfilepath != NULL)
    {
        ret->dtd_filename = allocate_copy_string(dtdfilepath);
        if (ret->dtd_filename == NULL)
        {
            LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate dtd filename copy.");
            dar_drc_destroy(ret);
            return NULL;
        }
    } else {
        ret->dtd_filename = NULL;
    }
    
    validate_drc(ret, exception);
    if (exception->type != LIBDAR_NOEXCEPT)
    {
        DEBUG("Exception caught, cleaning up and throwing.\n");
        dar_drc_destroy(ret);
        return NULL;
    }
    
    interpret_drc(ret, exception);
    if (exception->type != LIBDAR_NOEXCEPT)
    {
        DEBUG("Exception caught, cleaning up and throwing.\n");
        dar_drc_destroy(ret);
        return NULL;
    }
    
    DEBUG("File parsing complete, returning drc object.\n");
    return ret;
}

dar_drc *dar_drc_parse_xml_file( const char* filename, 
    const char* dtdfilepath, dar_sup_exception* exception)
{
    exception->type = LIBDAR_NOEXCEPT;
    
    DEBUG("Function: dar_drc_parse_xml_file: Building drc from file.\n");
    dar_drc* ret = (dar_drc*)malloc(sizeof(dar_drc));
    if (ret == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate drc context object.");
        return NULL;
    }
    
    /* set defaults, prep for panic on caught exceptions, and allocate
     * internal storage
     */
     
    DEBUG("Preping drc content.\n");
     
    if ( !dar_drc_prep(ret) )
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate drc internal storage.");
        free(ret);
        return NULL;
    }
    
    ret->read_mode = read_file;
    ret->xml_filename = allocate_copy_string(filename);
    if (ret->xml_filename == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate xml filename copy.");
        dar_drc_destroy(ret);
        return NULL;
    }
    ret->doc = xmlReadFile(filename, NULL, 0);
    if (ret->doc == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_X_EINPUTSPEC,
            "Failed to parse xml file.");
        dar_drc_destroy(ret);
        return NULL;
    }
    
    if (dtdfilepath != NULL)
    {
        ret->dtd_filename = allocate_copy_string(dtdfilepath);
        if (ret->dtd_filename == NULL)
        {
            LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate dtd filename copy.");
            dar_drc_destroy(ret);
            return NULL;
        }
    } else {
        ret->dtd_filename = NULL;
    }
    
    
    validate_drc(ret, exception);
    if (exception->type != LIBDAR_NOEXCEPT)
    {
        DEBUG("Exception caught, cleaning up and throwing.\n");
        dar_drc_destroy(ret);
        return NULL;
    }
    
    interpret_drc(ret, exception);
    if (exception->type != LIBDAR_NOEXCEPT)
    {
        DEBUG("Exception caught, cleaning up and throwing.\n");
        dar_drc_destroy(ret);
        return NULL;
    }
    
    DEBUG("File parsing complete, returning drc object.\n");
    return ret;
}

static void validate_drc(dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: validate_drc: Validating drc file against dtd.\n");
    
    
    /* get xml file version */
    DEBUG("Determining xml file version.\n");
    
    xmlNodePtr root = xmlDocGetRootElement(ref->doc);
    
    if ( strcmp("JobSettings", root->name) != 0 )
    {
        DEBUG("Root node named %s.\n", root->name);
        LIBDARC_EXCEPTION( exception, LIBDAR_X_EINPUTSPEC,
            "Input file not valid, incorrect root node.");
        return;
    }
    
    if ( !xmlHasProp(root, "FileVersion") )
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_X_EINPUTSPEC,
            "Input file not valid, file version not present.");
        return;
    }
    
    xmlChar* version = xmlGetProp(root, "FileVersion");
    if (version == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate version attribute copy.");
        return;
    }
    DEBUG("Input file version: %s\n", version);
    
    if ( strcmp( version, "1.0" ) == 0 )
    {
        ref->dtd_version = 10;
    } else {
        LIBDARC_EXCEPTION( exception, LIBDAR_X_EINPUTSPEC,
            "Input file version not supported.");
    }
    
    DEBUG("Loading dtd.\n");
    
    char* filename = ref->dtd_filename;
    ref->dtd_filename = get_dtd_location( filename, version );
    if (ref->dtd_filename == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate dtd path.");
        return;
    }
    if (filename != NULL)
        free(filename);
    xmlFree(version);
    
    DEBUG("Dtd file path: %s\n", ref->dtd_filename);
    
    xmlValidCtxtPtr ctxt = xmlNewValidCtxt();
    if (ctxt == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate xml validation context.");
        return;
    }
    
    xmlDtdPtr dtd = xmlParseDTD(NULL, ref->dtd_filename);
    if (dtd == NULL)
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate dtd object.");
        xmlFreeValidCtxt(ctxt);
        return;
    }
    
    if ( !xmlValidateDtd( ctxt, ref->doc, dtd ) )
    {
        LIBDARC_EXCEPTION( exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, validation against DTD failed.");
        xmlFreeValidCtxt(ctxt);
        return;
    }
    xmlFreeValidCtxt(ctxt);
    
    DEBUG("Freeing dtd context.\n");
    xmlFreeDtd(dtd);
    
    return; 
}

static void interpret_drc(dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc: Translating drc xml tree to libdarc specs.\n");
    
    switch ( ref->dtd_version )
    {
        case 10: /* 1.0 */
            interpret_drc_1_0(ref, exception);
            DEBUG("Exit function: interpret_drc_1_0\n");
            DEBUG("Returned: %d\n", exception->type);
            break;
        default:
            LIBDARC_EXCEPTION(exception, LIBDAR_EBUG,
                "Requested drc interpreter invalid.");
            break;
    }
    return;
}




/* interpreter definitions */

/* pass MaskUnion or Mask element */
static dar_mask *interpret_drc_1_0_recurse_mask(xmlNodePtr node,
            dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0_recurse_mask: Interpret mask elements.\n");
    
    xmlChar* type = xmlGetProp(node, "Type");
    if (type == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate attribute copy.");
    }
    DEBUG("Element type: %s\n", type);
    
    dar_mask* ret;
    
    /* process MaskUnion elements first, then Mask elements */
    if ( strcmp( node->name, "MaskUnion") == 0 )
    {
        enum { type_or, type_and, type_not } union_type;
        
        
        DEBUG("Interpreting MaskUnion type.\n");
        dar_mask* in = NULL;
        xmlNodePtr tmp = node->children;
        
        DEBUG("Building specific mask union container.\n");
        
        if ( strcmp(type, "and") == 0 )
        {
            DEBUG("And union found.\n");
            union_type = type_and;
            ret = dar_mask_create_and();
        } else if ( strcmp(type, "or") == 0 )
        {
            DEBUG("Or union found.\n");
            union_type = type_or;
            ret = dar_mask_create_or();
        } else if ( strcmp(type, "not") == 0 )
        { /* contains its own child seek loop, doesn't use shared loop below */
            DEBUG("Not union found.\n");
            union_type = type_not;
            
            dar_mask* in = NULL;
            xmlNodePtr tmp = node->children;
            
            DEBUG("Finding union element.\n"); /* only one element */
            
            do
            {
                DEBUG("Element type: %d\n", tmp->type);
                DEBUG("Element name: %s\n", tmp->name);
                if ( tmp->type == XML_ELEMENT_NODE )
                {
                    DEBUG("Element selected.\n");
                    in = interpret_drc_1_0_recurse_mask(tmp, ref, exception);
                    if ( exception->type != LIBDAR_NOEXCEPT)
                    {
                        xmlFree(type);
                        return NULL;
                    } 
                    break;
                }
            } while ( (tmp = tmp->next) != tmp->last );
            
            if (in == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                    "Input file invalid, no child node for not mask.");
                xmlFree(type);
                return NULL;
            }
            
            ret = dar_mask_create_not(in);
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            dar_mask_destroy(in);
            return ret;
        } else {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, mask union type not valid.");
            xmlFree(type);
            return NULL;
        } /* end of type selection, and/or mask unions continue here */
        
        if (ret == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate mask object.");
            xmlFree(type);
            return NULL;
        }
        
        DEBUG("Finding union elements.\n");
        
        for (; tmp; tmp = tmp->next)
        {
            DEBUG("Next node: %s\n", tmp->name);
            
            if (tmp->type == XML_ELEMENT_NODE)
            {
                DEBUG("Element selected.\n");
                in = interpret_drc_1_0_recurse_mask(tmp, ref, exception);
                if ( exception->type != LIBDAR_NOEXCEPT )
                {
                    dar_mask_destroy(ret);
                    xmlFree(type);
                    return NULL;
                } else {
                    switch(union_type)
                    {
                        case type_and:
                            dar_mask_and_add(ret, in);
                            break;
                        case type_or:
                            dar_mask_or_add(ret, in);
                            break;
                        default:
                            LIBDARC_EXCEPTION(exception, LIBDAR_EBUG,
                                "Invalid mask union type selected.");
                            dar_mask_destroy(in);
                            dar_mask_destroy(ret);
                            xmlFree(type);
                            return NULL;
                    }
                }
                dar_mask_destroy(in);
            }
        }
        xmlFree(type);
        return ret;
        
    } else {
        DEBUG("Check for mask element properties.\n");
        
        bool case_sensit = true;
        if ( xmlHasProp(node, "CaseSensitive") )
        {
            xmlChar* cs_tmp = xmlGetProp(node, "CaseSensitive");
            if ( !string_to_bool( cs_tmp, &case_sensit ) )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                    "Input file invalid, could not parse case sensitive setting.");
                xmlFree(cs_tmp);
                xmlFree(type);
                return NULL;
            }
            xmlFree(cs_tmp);
        }
        
        
        if ( strcmp(type, "samepath") == 0 )
        {
            DEBUG("Samepath node type found.\n");
            xmlChar* cont = xmlNodeGetContent(node);
            ret = dar_mask_create_same_path(cont, case_sensit);
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            xmlFree(cont);
            return ret;
        } else if ( strcmp(type, "boolean") == 0 )
        {
            DEBUG("Boolean node type found.\n");
            xmlChar* cont = xmlNodeGetContent(node);
            bool tmpb;
            if ( !string_to_bool( cont, &tmpb ) )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                    "Input file invalid, could not parse boolean mask setting.");
                xmlFree(type);
                xmlFree(cont);
                return NULL;
            }
            ret = dar_mask_create_bool( tmpb );
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            xmlFree(cont);
            return ret;
        } else if ( strcmp(type, "excludedir") == 0 )
        {
            DEBUG("Exclude dir node type found.\n");
            xmlChar* cont = xmlNodeGetContent(node);
            ret = dar_mask_create_exclude_dir(cont, case_sensit);
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            xmlFree(cont);
            return ret;
        } else if ( strcmp(type, "regular") == 0 )
        {
            DEBUG("Regular node type found.\n");
            xmlChar* cont = xmlNodeGetContent(node);
            ret = dar_mask_create_regular(cont, case_sensit);
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            xmlFree(cont);
            return ret;
        } else if ( strcmp(type, "simple") == 0 )
        {
            DEBUG("Simple node type found.\n");
            xmlChar* cont = xmlNodeGetContent(node);
            ret = dar_mask_create_simple(cont, case_sensit);
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            xmlFree(cont);
            return ret;
        } else if ( strcmp(type, "simplepath") == 0 )
        {
            DEBUG("Simple path node type found.\n");
            xmlChar* cont = xmlNodeGetContent(node);
            ret = dar_mask_create_simple_path(cont, case_sensit);
            if (ret == NULL)
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate mask object.");
            }
            xmlFree(type);
            xmlFree(cont);
            return ret;
        } else {
            DEBUG("Invalid node type found: %s\n", type);
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, mask type not supported.");
            xmlFree(type);
            return NULL;
        }
    }
}

/* TODO: The following function should be optimized at some point. */

/* pass first child of Flags element. */
static void interpret_drc_1_0_recurse_flags(xmlNodePtr node,
            dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0_recurse_flags: Interpret flag elements.\n");
    if ( node == NULL )
    {
        return;
    }
    
    /* switch across flag types */
    bool tmp;
    xmlChar* cont = xmlNodeGetContent(node);
    if (!string_to_bool(cont, &tmp))
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, flag content not valid.");
        if (cont != NULL)
            xmlFree(cont);
        return;
    }
    xmlFree(cont);
    
    DEBUG("Element name: %s\n", node->name);
    DEBUG("Element value: %d\n", tmp);
    
    if ( strcmp(node->name, "AllowOverwrite") == 0 )
    {
        ref->flags->allow_overwrite = tmp;
    } else if ( strcmp(node->name, "WarnOverwrite") == 0 )
    {
        ref->flags->warn_overwrite = tmp;
    } else if ( strcmp(node->name, "SlicePause") == 0 )
    {
        ref->flags->slice_pause = tmp;
    } else if ( strcmp(node->name, "CreateEmptyStubs") == 0 )
    {
        ref->flags->create_empty_stubs = tmp;
    } else if ( strcmp(node->name, "EaSystem") == 0 )
    {
        ref->flags->ea_system = tmp;
    } else if ( strcmp(node->name, "EaUser") == 0 )
    {
        ref->flags->ea_user = tmp;
    } else if ( strcmp(node->name, "NoDump") == 0 )
    {
        ref->flags->no_dump = tmp;
    } else if ( strcmp(node->name, "IgnoreOwner") == 0 )
    {
        ref->flags->ignore_owner = tmp;
    } else if ( strcmp(node->name, "TestRun") == 0 )
    {
        ref->flags->test_run = tmp;
    } else if ( strcmp(node->name, "AlterAtime") == 0 )
    {
        ref->flags->alter_atime = tmp;
    } else if ( strcmp(node->name, "SameFs") == 0 )
    {
        ref->flags->same_fs = tmp;
    } else if ( strcmp(node->name, "DeleteMarked") == 0 )
    {
        ref->flags->delete_marked = tmp;
    } else if ( strcmp(node->name, "RestoreFlat") == 0 )
    {
        ref->flags->restore_flat = tmp;
    } else if ( strcmp(node->name, "WarnRemoveNoMatch") == 0 )
    {
        ref->flags->warn_remove_no_match = tmp;
    } else if ( strcmp(node->name, "OnlyMoreRecent") == 0 )
    {
        ref->flags->only_more_recent = tmp;
    } else if ( strcmp(node->name, "TarFormat") == 0 )
    {
        ref->flags->tar_format = tmp;
    } else if ( strcmp(node->name, "FilterUnsaved") == 0 )
    {
        ref->flags->filter_unsaved = tmp;
    } else
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, flag element unsupported.");
    }
    
    node = get_next_element_node(node->next);
    
    interpret_drc_1_0_recurse_flags(node, ref, exception);
    return;
}

/* pass Encryption element */   
static void interpret_drc_1_0_encryption(xmlNodePtr node,
            dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0_encryption: Interpreting encryption element.\n");
    xmlChar* algo = xmlGetProp(node, "Algorithm");
    
    if (strcmp( algo, "none" ) == 0 )
    {
        ref->storage->crypto_algo = dar_crypto_none;
        xmlFree(algo);
        return;
    }   
    
    if ( strcmp( algo, "blowfish" ) == 0 )
    {
        ref->storage->crypto_algo = dar_crypto_blowfish;
    } else if ( strcmp( algo, "scrambling" ) == 0 )
    {
        ref->storage->crypto_algo = dar_crypto_scrambling;
    } else
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, encryption algorithm unsupported.");
        xmlFree(algo);
        return;
    }
    xmlFree(algo);
    
    xmlChar* block = xmlGetProp(node, "BlockSize");
    
    errno = 0;
    long s = strtol(block, NULL, 10);
    if ( errno != 0 || s >= U_32_MAX )
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, could not parse block size.");
        xmlFree(block);
        return;
    }
    xmlFree(block);
    
    ref->storage->crypto_size = (U_32)s;
    
    xmlChar* cont = xmlNodeGetContent(node);
    if ( cont == NULL || strcmp ( cont, "" ) == 0 )
    {
        return;
    } else {
        ref->storage->crypto_pass = allocate_copy_string(cont);
        if ( ref->storage->crypto_pass == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate passphrase copy.");
        }
    }
    
    if ( cont != NULL )
        xmlFree(cont);
    
    return;
}

/* pass Compression element */
static void interpret_drc_1_0_compression(xmlNodePtr node,
            dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0_compression: Interpreting compression element.\n");
    xmlChar* algo = xmlGetProp(node, "Algorithm");
    
    if ( strcmp( algo, "none" ) == 0 )
    {
        ref->storage->compress_algo = dar_compression_none;
        xmlFree(algo);
        return;
    }
    
    if ( strcmp( algo, "zip" ) == 0 )
    {
        ref->storage->compress_algo = dar_compression_zip;
    } else if ( strcmp( algo, "gzip" ) == 0 )
    {
        ref->storage->compress_algo = dar_compression_gzip;
    } else if ( strcmp( algo, "bzip2" ) == 0 )
    {
        ref->storage->compress_algo = dar_compression_bzip2;
    } else 
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, compression algorithm unsupported.");
        xmlFree(algo);
        return;
    }
    xmlFree(algo);
    
    xmlChar* tn = xmlGetProp(node, "Level");
    
    errno = 0;
    long s = strtol(tn, NULL, 10);
    if ( errno != 0 || s > 9 )
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, compression level invalid.");
        xmlFree(tn);
        return;
    }
    xmlFree(tn);
    
    ref->storage->compress_level = (U_I)s;
    
    tn = xmlGetProp(node, "MinSize");
    
    dar_infinint* si = dar_infhs(tn);
    if ( si == NULL )
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, compression minimum size invalid.");
        xmlFree(tn);
        dar_infinint_destroy(si);
        return;
    }
    xmlFree(tn);
    
    ref->storage->compress_min_size = si;
    
    xmlNodePtr ch = node->children;
    
    if ( ch->type != XML_ELEMENT_NODE )
    {
        ch = get_next_element_node(ch);
    }
    
    ref->storage->compress_mask = 
            interpret_drc_1_0_recurse_mask(ch, ref, exception);
    if ( exception->type != LIBDAR_NOEXCEPT )
    {
        DEBUG("Exception caught, throwing.\n");
        return;
    }
    return;
}

/* pass SliceSize element */
static void interpret_drc_1_0_slice_size(xmlNodePtr node,
            dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0_slice_size: Interpreting slice size element.\n");
    xmlChar* tmp = NULL;
    if ( xmlHasProp( node, "Initial" ) )
    {
        tmp = xmlGetProp(node, "Initial");
        if (tmp == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate copy of intial size.");
            return;
        }
        dar_infinint* ti = dar_tools_get_extended_size(tmp, 1024);
        if (ti == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, could not parse initial slice size.");
            xmlFree(tmp);
            return;
        }
        xmlFree(tmp);
        ref->storage->first_file_size = ti;
    }
    tmp = xmlNodeGetContent(node);
    if (tmp == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate copy of size element.");
        return;
    }
    dar_infinint* tib = dar_tools_get_extended_size(tmp, 1024);
    if (tib == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, could not parse slice size.");
        xmlFree(tmp);
        return;
    }
    xmlFree(tmp);
    ref->storage->file_size = tib;
    
    return;
}

/* pass Archive element */
static void interpret_drc_1_0_archive(xmlNodePtr node,
            dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0_archive: Interpreting archive element.\n");
    if ( !xmlHasProp(node, "Type") )
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, archive element does not have type attribute.");
        return;
    }
    
    xmlChar* type = xmlGetProp(node, "Type");
    if (type == NULL)
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
            "Memory exhausted, could not allocate copy of archive spec type.");
        return;
    }
    
    xmlChar* tmp = NULL;
    if ( strcmp(type, "pipeset") == 0 )
    {
        xmlFree(type);
        tmp = xmlNodeGetContent(node);
        if (tmp == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, pipe elements not listed in archive element.");
            return;
        }
        char* l = NULL;
        char* t = NULL;
        t = strtok_r(tmp, ";", &l);
        if (t == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, input pipe string not found.");
            xmlFree(tmp);
            return;
        }
        ref->spec->input_pipe = allocate_copy_string(t);
        if ( ref->spec->input_pipe == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate copy of input pipe.");
        }
        t = strtok_r(NULL, ";", &l);
        if (t == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, output pipe string not found.");
            xmlFree(tmp);
            return;
        }
        ref->spec->output_pipe = allocate_copy_string(t);
        if ( ref->spec->output_pipe == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate copy of output pipe.");
        }
        xmlFree(tmp);
        
        ref->spec->arc_path = allocate_copy_string("");
        if ( ref->spec->arc_path == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate empty archive path.");
        }
        
        ref->spec->arc_ext = allocate_copy_string("dar");
        if ( ref->spec->arc_ext == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate set archive extension.");
        }
        
        /* "-" activates pipeset in libdar library */
        ref->spec->arc_name = allocate_copy_string("-");
        if ( ref->spec->arc_name == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate set archive name.");
        }
        
    } else if ( strcmp(type, "file") == 0 )
    {
        xmlFree(type);
        
        if ( xmlHasProp(node, "Root") ) /* setting this optional, else default */
        {
            tmp = xmlGetProp(node, "Root");
            ref->spec->arc_path = allocate_copy_string(tmp);
            if ( ref->spec->arc_path == NULL )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate copy of archive path.");
                xmlFree(tmp);
                return;
            }
            xmlFree(tmp);
        } else
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, archive path not indicated.");
            return;
        }
        
        if ( xmlHasProp(node, "Extension") ) /* also optional */
        {
            tmp = xmlGetProp(node, "Extension");
            ref->spec->arc_ext = allocate_copy_string(tmp);
            if ( ref->spec->arc_ext == NULL )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate copy of archive extension.");
                xmlFree(tmp);
                return;
            }
            xmlFree(tmp);
        } else
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, archive extension not indicated.");
            return;
        }
        
        tmp = xmlNodeGetContent(node);
        if (tmp == NULL)
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                "Input file invalid, archive name not found.");
            xmlFree(tmp);
            return;
        }
        
        ref->spec->arc_name = allocate_copy_string(tmp);
        if ( ref->spec->arc_name == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate copy of archive name.");
            xmlFree(tmp);
            return;
        }
        xmlFree(tmp);
        
        ref->spec->input_pipe = allocate_copy_string("");
        if ( ref->spec->input_pipe == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate set input pipe name.");
        }
        
        ref->spec->output_pipe = allocate_copy_string("");
        if ( ref->spec->output_pipe == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate set output pipe name.");
        }
        
    } else
    {
        xmlFree(type);
        
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, archive type invalid.");
        return;
    }
    return;
}





static void interpret_drc_1_0(dar_drc* ref, dar_sup_exception* exception)
{
    DEBUG("Function: interpret_drc_1_0: Interpreting drc version 1.0.\n");
    
    xmlNodePtr root = xmlDocGetRootElement(ref->doc);
    xmlNodePtr ch = root->children;
    xmlNodePtr ch2 = NULL;
    xmlNodePtr ch3 = NULL;
    xmlNodePtr ch4 = NULL;
    xmlChar* xctmp = NULL;
    
    DEBUG("Root node name: %s\n", root->name);
    DEBUG("First child node name: %s\n", ch->name);
    
    DEBUG("Seeking Specification(1) element.\n");
    
    if ( ch->type != XML_ELEMENT_NODE )
    {
        DEBUG("Finding next element node.\n");
        ch = get_next_element_node(ch);
    }
    
    if ( ch == NULL || strcmp(ch->name, "Specification") != 0 )
    {
        LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
            "Input file invalid, could not find archive specification.");
        return;
    }
    
    DEBUG("Found, translating specification element.\n");
    
    /* Filesystem */
    ch2 = ch->children;
    DEBUG("Seeking Filesystem(2) element.\n");
    
    if ( ch2->type != XML_ELEMENT_NODE )
    {
        ch2 = get_next_element_node(ch2);
    }
    
    if ( xmlHasProp(ch2, "Root") )
    {
        xctmp = xmlGetProp(ch2, "Root");
        ref->spec->root_path = allocate_copy_string(xctmp);
        if ( ref->spec->root_path == NULL )
        {
            LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                "Memory exhausted, could not allocate copy of root path.");
            xmlFree(xctmp);
            return;
        }
        xmlFree(xctmp);
    }
    
    /* Selection */
    ch3 = ch2->children;
    DEBUG("Seeking Selection(3) element.\n");
    
    if ( ch3 != NULL && ch3->type != XML_ELEMENT_NODE )
    {
        ch3 = get_next_element_node(ch3);
    }
    
    if ( ch3 != NULL && strcmp(ch3->name, "Selection") == 0 )
    {
        /* Mask */
        ch4 = ch3->children;
        DEBUG("Seeking Mask(4) element.\n");
        
        if ( ch4->type != XML_ELEMENT_NODE )
        {
            ch4 = get_next_element_node(ch4);
        }
        
        dar_mask* tmpmask = 
            interpret_drc_1_0_recurse_mask(ch4, ref, exception);
        
        if ( exception->type != LIBDAR_NOEXCEPT )
        {
            DEBUG("Exception caught, throwing.\n");
            return;
        }
        
        ref->spec->selection = tmpmask;
        
        /* Subtree */
        DEBUG("Seeking Subtree(3) element.\n");
        ch3 = get_next_element_node(ch3->next);
    }

    if ( ch3 != NULL && strcmp(ch3->name, "Subtree") == 0 )
    {
        /* Mask */
        DEBUG("Seeking Mask(4) element.\n");
        ch4 = ch3->children;
        
        
        if ( ch4->type != XML_ELEMENT_NODE )
        {
            ch4 = get_next_element_node(ch4);
        }
        
        dar_mask* tmpmask =
            interpret_drc_1_0_recurse_mask(ch4, ref, exception);
        
        if ( exception->type != LIBDAR_NOEXCEPT )
        {
            DEBUG("Exception caught, throwing.\n");
            return;
        }
        
        ref->spec->subtree = tmpmask;
    }
    
    /* Archive */
    DEBUG("Seeking Archive(2) element.\n");
    ch2 = get_next_element_node(ch2->next);
    
    
    interpret_drc_1_0_archive(ch2, ref, exception);
    
    if ( exception->type != LIBDAR_NOEXCEPT )
    {
        DEBUG("Exception caught, throwing.\n");
        return;
    }
    
    DEBUG("Finding reference element, continuing if not found.\n");
    
    /* Reference */
    DEBUG("Seeking Reference(1) element.\n");
    ch = get_next_element_node(ch->next);
    
    
    if ( ch != NULL && strcmp(ch->name, "Reference") == 0 )
    {
        DEBUG("Reference element found, processing.\n");
        
        /* dar_drc object needs to be copied because spec, etc, objects
         * are modified directly by processing functions. Therefore, ref_spec,
         * etc, objects need to be placed in those slots during processing
         * of the reference element.
         */
         
        ref->has_reference = true;
        
        dar_drc temp_ref;
        
        temp_ref.spec = ref->ref_spec;
        temp_ref.storage = ref->ref_storage;
        temp_ref.flags = ref->ref_flags;
        
        /* Archive */
        ch2 = ch->children;
        DEBUG("Seeking Archive(2) element.\n");
        
        if ( ch2->type != XML_ELEMENT_NODE )
        {
            ch2 = get_next_element_node(ch2);
        }
        
        interpret_drc_1_0_archive(ch2, &temp_ref, exception);
        
        if ( exception->type != LIBDAR_NOEXCEPT )
        {
            DEBUG("Exception caught, throwing.\n");
            return;
        }
        
        /* Encryption */
        DEBUG("Seeking Encryption(2) element.\n");
        ch2 = get_next_element_node(ch2->next);
        
        if ( ch2 != NULL && strcmp(ch2->name, "Encryption") == 0 )
        {
            interpret_drc_1_0_encryption(ch2, &temp_ref, exception);
            
            if ( exception->type != LIBDAR_NOEXCEPT )
            {
                DEBUG("Exception caught, throwing.\n");
                return;
            }
            
            /* Script */
            DEBUG("Seeking Script(2) element.\n");
            ch2 = get_next_element_node(ch2->next);
        }
        
        if ( ch2 != NULL && strcmp(ch2->name, "Script") == 0 )
        {
        
            xctmp = xmlNodeGetContent(ch2);
            temp_ref.storage->slice_execute = allocate_copy_string(xctmp);
            
            if ( temp_ref.storage->slice_execute == NULL && xctmp != NULL )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate copy of inter-slice command.");
                xmlFree(xctmp);
                return;
            }
            xmlFree(xctmp);
        }
        
        /* temp_ref variables were just pointers to ref objects,
         * we don't need to copy pointers over before temp_ref deallocation,
         * which happens here.
         */
         
         /* moving to next element */
         ch = get_next_element_node(ch->next);
    }
    
    DEBUG("Finding storage element, continuing if not found.\n");
    
    /* Storage */
    
    if ( ch != NULL && strcmp(ch->name, "Storage") == 0 )
    {
        DEBUG("Storage element found, processing.\n");
        
        /* Compression */
        ch2 = ch->children;
        DEBUG("Seeking Compression(2) element.\n");
        
        if ( ch2->type != XML_ELEMENT_NODE )
        {
            ch2 = get_next_element_node(ch2);
        }
        
        if ( ch2 != NULL && strcmp(ch2->name, "Compression") == 0 )
        {
            interpret_drc_1_0_compression(ch2, ref, exception);
            
            if ( exception->type != LIBDAR_NOEXCEPT )
            {
                DEBUG("Exception caught, throwing.\n");
                return;
            }
            
            /* Encryption */
            DEBUG("Seeking Encryption(2) element.\n");
            ch2 = get_next_element_node(ch2->next);
        }
        
        if ( ch2 != NULL && strcmp(ch2->name, "Encryption") == 0 )
        {
            interpret_drc_1_0_encryption(ch2, ref, exception);
            
            if ( exception->type != LIBDAR_NOEXCEPT )
            {
                DEBUG("Exception caught, throwing.\n");
                return;
            }
            
            /* SliceSize */
            DEBUG("Seeking SliceSize(2) element.\n");
            ch2 = get_next_element_node(ch2->next);
        }
        
        if ( ch2 != NULL && strcmp(ch2->name, "SliceSize") == 0 )
        {
            interpret_drc_1_0_slice_size(ch2, ref, exception);
            
            if ( exception->type != LIBDAR_NOEXCEPT )
            {
                DEBUG("Exception caught, throwing.\n");
                return;
            }
            
            /* Script */
            DEBUG("Seeking Script(2) element.\n");
            ch2 = get_next_element_node(ch2->next);
        }
        
        if ( ch2 != NULL && strcmp(ch2->name, "Script") == 0 )
        {
            xctmp = xmlNodeGetContent(ch2);
            ref->storage->slice_execute = allocate_copy_string(xctmp);
            
            if ( ref->storage->slice_execute == NULL && xctmp != NULL )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_EMEMORY,
                    "Memory exhausted, could not allocate copy of inter-slice command.");
                xmlFree(xctmp);
                return;
            }
            xmlFree(xctmp);
            
            /* Hourshift */
            DEBUG("Seeking Hourshift(2) element.\n");
            ch2 = get_next_element_node(ch2->next);
        }
        
        if ( ch2 != NULL && strcmp(ch2->name, "Hourshift") == 0 )
        {
            xctmp = xmlNodeGetContent(ch2);
            ref->storage->hourshift = dar_infds(xctmp);
            
            if ( ref->storage->hourshift == NULL )
            {
                LIBDARC_EXCEPTION(exception, LIBDAR_X_EINPUTSPEC,
                    "Input file invalid, could not parse hourshift value.");
                xmlFree(xctmp);
                return;
            }
            xmlFree(xctmp);
        }
        
         /* moving to next element */
         ch = get_next_element_node(ch->next);
    }
    
    DEBUG("Finding flags element, continuing if not found.\n");
    
    if ( ch != NULL && strcmp(ch->name, "Flags") == 0 )
    {
        DEBUG("Flags element found, processing.\n");
        
        /* first flag element */
        ch2 = ch->children;
    
        if ( ch2->type != XML_ELEMENT_NODE )
        {
            ch2 = get_next_element_node(ch2);
        }
        
        interpret_drc_1_0_recurse_flags(ch2, ref, exception);
        
        if ( exception->type != LIBDAR_NOEXCEPT )
        {
            DEBUG("Exception caught, throwing.\n");
            return;
        }
        
         /* moving to next element */
         ch = get_next_element_node(ch->next);
    }
    
    return;
}





/* internal functions definitions */

static char* bool_to_string( bool val )
{
    DEBUG("Function: bool_to_string: Converting boolean to string.\n");
    char* ret;
    if (val)
    {
        ret = (char*)malloc(5);
        if (ret == NULL) { return NULL; }
        strcpy(ret, "true");
    } else {
        ret = (char*)malloc(6);
        if (ret == NULL) { return NULL; }
        strcpy(ret, "false");
    }
    return ret;
}

static bool string_to_bool( char* str, bool* val )
{
    DEBUG("Function: string_to_bool: Converting string to boolean.\n");
    
    if (val == NULL)
    {
        DEBUG("Source error: Input parameter is null.\n");
        return false;
    }
    
    if (str == NULL)
    {
        DEBUG("Argument error: No input string.\n");
        return false;
    }
    
    if ( strcmp( str, "true" ) == 0 )
    {
        *val = true;
        return true;
    } else if ( strcmp( str, "false" ) == 0 )
    {
        *val = false;
        return true;
    } else {
        DEBUG("Argument error: Improper input data format.\n");
        return false;
    }
}

static char* allocate_copy_string( const char* source )
{
    DEBUG("Function: allocate_copy_string: Copying string into newly allocated space.\n");
    if (source == NULL) { return NULL; }
    char* ret = (char*)malloc(strlen(source) + 1);
    if (ret == NULL) { return NULL; }
    strcpy( ret, source );
    return ret;
}

/* DRC_DTD_FILE_PREFIX and DRC_DTD_FILE_LOCATION defined in Makefile.am */

static char* get_dtd_location(const char* dtdfilepath, const char* version)
{
    DEBUG("Function: get_dtd_location: Determining dtd file location.\n");
    const char* prefix = DRC_DTD_FILE_PREFIX;
    const char* path = DRC_DTD_FILE_LOCATION;
    
    char* ret;
    
    if ( dtdfilepath != NULL )
    {
        DEBUG("dtdfilepath = %s\n", dtdfilepath);
        ret = (char*)malloc(strlen(dtdfilepath));
        if (ret == NULL) { return NULL; }
        strcpy( ret, dtdfilepath );
        return ret;
    }
    
#if WIN32_PLATFORM
    /* "..\\share\\libdarc\\" + PREFIX + "-" + VERSION + ".dtd" + "\0" -> 23 */
    ret = (char*)malloc( strlen(prefix) + strlen(version) + 23 );
    if (ret == NULL) { return NULL; }
    *ret = 0;
    strcat(ret, "..\\share\\libdarc\\");
    strcat(ret, prefix);
    strcat(ret, "-");
    strcat(ret, version);
    strcat(ret, ".dtd");
#else
    /* PATH + DIR_SEPERATOR_STR + PREFIX + "-" + VERSION + ".dtd" + "\0" -> 7 */
    ret = (char*)malloc( strlen(path) + strlen(prefix) + strlen(version) + 7 );
    if (ret == NULL) { return NULL; }
    *ret = 0;
    strcat(ret, path);
    strcat(ret, DIR_SEPARATOR_STR);
    strcat(ret, prefix);
    strcat(ret, "-");
    strcat(ret, version);
    strcat(ret, ".dtd");
#endif
    
    return ret;
}

/* returns false if allocation fails */
static bool dar_drc_prep(dar_drc* ref)
{
    DEBUG("Function: dar_drc_prep: Zeroing out drc context.\n");
    /* set pointers to NULL to prep for dar_drc_destroy on panic */
    ref->xml_buffer = NULL;
    ref->xml_filename = NULL;
    ref->dtd_filename = NULL;
    ref->doc = NULL;
    
    ref->xml_buffer_size = 0;
    
    ref->has_reference = false;
    
    ref->spec = (dar_sup_spec*)malloc(sizeof(dar_sup_spec));
    ref->storage = (dar_sup_storage*)malloc(sizeof(dar_sup_storage));
    ref->flags = (dar_sup_flags*)malloc(sizeof(dar_sup_flags));
    
    ref->ref_spec = (dar_sup_spec*)malloc(sizeof(dar_sup_spec));
    ref->ref_storage = (dar_sup_storage*)malloc(sizeof(dar_sup_storage));
    ref->ref_flags = (dar_sup_flags*)malloc(sizeof(dar_sup_flags));
    
    if (    ref->spec == NULL ||
            ref->storage == NULL ||
            ref->flags == NULL ||
            ref->ref_spec == NULL ||
            ref->ref_storage == NULL ||
            ref->ref_flags == NULL )
    {
        DEBUG("Memory exhausted, allocation failed in dar_drc_prep.\n");
        if (ref->spec != NULL)
            free(ref->spec);
        if (ref->storage != NULL)
            free(ref->storage);
        if (ref->flags != NULL)
            free(ref->flags);
        if (ref->ref_spec != NULL)
            free(ref->ref_spec);
        if (ref->ref_storage != NULL)
            free(ref->ref_storage);
        if (ref->ref_flags != NULL);
            free(ref->ref_flags);
            
        ref->spec = NULL;
        ref->storage = NULL;
        ref->flags = NULL;
        ref->ref_spec = NULL;
        ref->ref_storage = NULL;
        ref->ref_flags = NULL;
        
        return false;
    }
    
    
    
    /* set defaults for support structures */
    dar_sup_spec_defaults(ref->spec);
    dar_sup_storage_defaults(ref->storage);
    dar_sup_flags_defaults(ref->flags);
    
    dar_sup_spec_defaults(ref->ref_spec);
    dar_sup_storage_defaults(ref->ref_storage);
    dar_sup_flags_defaults(ref->ref_flags);
    return true;
}

static xmlNodePtr get_next_element_node(xmlNodePtr node)
{
    DEBUG("Function: get_next_element_node: Scanning to next element node.\n");
    DEBUG("Node passed in: %s\n", node->name);
    xmlNodePtr n;
    
    for (n = node; n; n = n->next)
    {
        DEBUG("Next node: %s\n", n->name);
        if (n->type == XML_ELEMENT_NODE)
        {
            DEBUG("Found element node.\n");
            return n;
        }
    }
    return NULL;
}
        

---

API Copyright © 2005, Wesley Leggette - See Sourceforge project page for contact details.
Documents generated on Mon Mar 21 13:26:15 2005 by doxygen 1.2.18