path: root/collection/elapi_util.c

/*
    ELAPI

    Different serialization methods of the collection.

    Copyright (C) Dmitri Pal <dpal@redhat.com> 2009

    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 3 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, see <http://www.gnu.org/licenses/>.
*/


#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "elapi_collection.h"
#include "elapi_debug.h"
#include "elapi_util.h"

/* Return a static string based on type of the element */
const char *get_type(int type)
{
    switch(type) {
        case ELAPI_TYPE_STRING:     return ELAPI_TYPE_NAME_STRING;
        case ELAPI_TYPE_INTEGER:    return ELAPI_TYPE_NAME_INTEGER;
        case ELAPI_TYPE_UNSIGNED:   return ELAPI_TYPE_NAME_UNSIGNED;
        case ELAPI_TYPE_LONG:       return ELAPI_TYPE_NAME_LONG;
        case ELAPI_TYPE_ULONG:      return ELAPI_TYPE_NAME_ULONG;
        case ELAPI_TYPE_BINARY:     return ELAPI_TYPE_NAME_BINARY;
        default:                    return ELAPI_TYPE_NAME_UNKNOWN;
    }

}

/* Calculate the potential size of the item */ 
int get_data_len(int type, int length)
{
    int len = 0;

    DEBUG_STRING("util_get_item_len","Entry point");

    switch(type) {
        case ELAPI_TYPE_INTEGER:
        case ELAPI_TYPE_UNSIGNED:
        case ELAPI_TYPE_LONG:
        case ELAPI_TYPE_ULONG:
                                len = 15;
                                break;
        case ELAPI_TYPE_STRING: 
        case ELAPI_TYPE_BINARY:
                                len = length * 2 + 2; 
                                break;
        case ELAPI_TYPE_DOUBLE:
                                len = 64;
                                break;
        default:
                                len = 0;
                                break;
    }

    DEBUG_STRING("util_get_item_len","Exit point");

    return len;
}

/* Copy data escaping characters */
static int copy_esc(char *dest,char *source,char esc) 
{
    int i=0;
    int j=0;

    *(dest +j) = esc;
    j++;

    while(*(source+i) != '\0') {
        if((*(source+i) == '\\') ||
           (*(source+i) == esc)) {

            *(dest +j) = '\\';
            j++;
            
        }
        *(dest +j) = *(source +i);
        i++;
        j++;
    }
    *(dest +j) = esc;
    j++;

    return j; 
}



/* Grow buffer to accomodate more space */
int grow_buffer(struct serial_data *buf_data, int len)
{
    void *tmp;

    DEBUG_STRING("grow_buffer","Entry point");
    DEBUG_NUMBER("Current length: ",buf_data->length);
    DEBUG_NUMBER("Increment length: ",len);
    DEBUG_NUMBER("Expected length: ",buf_data->length+len);
    DEBUG_NUMBER("Current size: ",buf_data->size);

    /* Grow buffer if needed */
    while(buf_data->length+len >= buf_data->size) {
        errno = 0;
        tmp = realloc(buf_data->buffer,buf_data->size+BLOCK_SIZE);
        if(tmp == NULL) {
            DEBUG_NUMBER("Error. Failed to allocate memory. Errno: ",errno);
            return errno;
        }
        buf_data->buffer = (char *)(tmp);
        buf_data->size += BLOCK_SIZE;
        DEBUG_NUMBER("New size: ",buf_data->size);

    }

    DEBUG_NUMBER("Final size: ",buf_data->size);
    DEBUG_STRING("grow_buffer","Success Exit.");
    return EOK;
}

/* Specail function to add different formatting symbols to the output */
int put_marker(struct serial_data *buf_data, void *data, int len) 
{
    int error = EOK;

    DEBUG_STRING("put_marker","Entry point");
    DEBUG_NUMBER("Marker length: ",len);

    error = grow_buffer(buf_data, len);
    if(error) {
        DEBUG_NUMBER("grow_buffer failed with: ",error);
        return error; 
    }
    memcpy(buf_data->buffer+buf_data->length,data,len);
    buf_data->length+=len;
    *(buf_data->buffer+buf_data->length) = '\0';

    DEBUG_STRING("put_marker","Success exit");
    return error;
}

/* Add item's data */
int serialize(char *property_in,
              int property_len_in,
              int type,
              void *data_in,
              int length_in,
              void *custom_data,
              int *dummy)
{
    int len;
    struct serial_data *buf_data; 
    char *property;
    void *data;
    int  property_len;
    int length;
    int error = EOK;
    int i;

    DEBUG_STRING("serialize","Entry point");
    
    *dummy = 0;

    /* Check is there is buffer. If not allocate */
    buf_data = (struct serial_data *)(custom_data);
    if(buf_data == (struct serial_data *)(NULL)) {
        DEBUG_STRING("Error.","Storage data is not passed in!");
        return EINVAL;
    }
    if(buf_data->buffer == NULL) {
        DEBUG_STRING("First time use.","Allocating buffer.");
        errno = 0;
        buf_data->buffer = malloc(BLOCK_SIZE);
        if(buf_data->buffer == NULL) {
            DEBUG_NUMBER("Error. Failed to allocate memory. Errno: ",errno);
            return errno;
        }
        *(buf_data->buffer)='\0';
        buf_data->length=0;
        buf_data->size = BLOCK_SIZE;
    }

    DEBUG_NUMBER("Buffer len: ", buf_data->length);
    DEBUG_NUMBER("Buffer size: ", buf_data->size);
    DEBUG_STRING("Buffer: ", buf_data->buffer);

    /* Check the beginning of the collection */
    if(type == ELAPI_TYPE_COLLECTION) {
        DEBUG_STRING("Serializing collection: ", property_in);
        DEBUG_STRING("First header. ", "");
        if((error=put_marker(buf_data,"(",1))) return error;
        property = TEXT_COLLECTION;
        property_len = TEXT_COLLEN;
        data = property_in;
        length = property_len_in+1;
        type=ELAPI_TYPE_STRING;
        buf_data->nest_level++;
    }
    /* Check for subcollections */
    else if(type==ELAPI_TYPE_COLLECTIONREF) {
        /* Skip */
        return EOK;
    }
    /* Check for the end of the collection */
    else if(type==ELAPI_TYPE_END) {
        if((buf_data->length>0) && 
           (*(buf_data->buffer+buf_data->length-1) == ',')) {
            buf_data->length--;
            *(buf_data->buffer+buf_data->length) = '\0';
        }
        if(buf_data->nest_level>0) {
            buf_data->nest_level--;
            if((error=put_marker(buf_data,")",1))) return error;
        }
        return EOK;
    }
    else {
        property = property_in;
        property_len = property_len_in;
        data = data_in;
        length = length_in;
    } 

    DEBUG_STRING("Property: ", property);
    DEBUG_NUMBER("Property length: ", property_len);

    /* Start with property and "=" */
    if((error=put_marker(buf_data,property,property_len)) ||
       (error=put_marker(buf_data,"=",1))) return error;

    /* Get projected length of the item */
    len = get_data_len(type,length);
    DEBUG_NUMBER("Expected data length: ",len);
    DEBUG_STRING("Buffer so far: ", buf_data->buffer);

    /* Make sure we have enough space */ 
    if((error=grow_buffer(buf_data,len))) return error;

    /* Add the value */
    switch(type) {
        case ELAPI_TYPE_STRING:
                                /* No escaping for now */
                                len = copy_esc(buf_data->buffer+buf_data->length,(char *)(data),'"');
                                break;
        case ELAPI_TYPE_BINARY:
                                *(buf_data->buffer+buf_data->length) = '\'';
                                for(i=0;i<length;i++) sprintf(buf_data->buffer+buf_data->length+i*2 + 1,"%02X",*((unsigned char *)(data+i)));
                                len = length * 2 + 1;
                                *(buf_data->buffer+buf_data->length + len) = '\'';
                                len++;
                                break;
        case ELAPI_TYPE_INTEGER:
                                len = sprintf(buf_data->buffer+buf_data->length,"%d",*((int *)(data)));
                                break;
        case ELAPI_TYPE_UNSIGNED:
                                len = sprintf(buf_data->buffer+buf_data->length,"%u",*((unsigned int *)(data)));
                                break;
        case ELAPI_TYPE_LONG:
                                len = sprintf(buf_data->buffer+buf_data->length,"%ld",*((long *)(data)));
                                break;
        case ELAPI_TYPE_ULONG:
                                len = sprintf(buf_data->buffer+buf_data->length,"%lu",*((unsigned long *)(data)));
                                break;
        case ELAPI_TYPE_DOUBLE:
                                len = sprintf(buf_data->buffer+buf_data->length,"%.4f",*((double *)(data)));
                                break;
        default:
                                *(buf_data->buffer+buf_data->length) = '\0';
                                len = 0;
                                break;
    }

    /* Adjust length */
    buf_data->length+=len;
    *(buf_data->buffer+buf_data->length) = '\0';

    /* Always put a comma at the end */
    if((error=put_marker(buf_data,",",1))) return error;


    DEBUG_STRING("Data: ",buf_data->buffer);
    DEBUG_STRING("serialize","Exit point");
    return EOK;

}


/* Add item's data */
int xml_add(char *property,
            int property_len,
            int type,
            void *data,
            int length,
            void *custom_data,
            int *dummy)
{
    int rc;
    struct xml_data *buf_data; 
    int error = EOK;
    char *data_xml;
    char *name;

    DEBUG_STRING("xml_add","Entry point");

    *dummy = 0;

    /* Check is there is buffer. If not allocate */
    buf_data = (struct xml_data *)(custom_data);
    if(buf_data == (struct xml_data *)(NULL)) {
        DEBUG_STRING("Error.","Storage data is not passed in!");
        return EINVAL;
    }

    /* Check if there is buffer allocated */
    if(buf_data->buf == (xmlBufferPtr)(NULL)) {
        DEBUG_STRING("xml_add", "First use - allocating memory");
        buf_data->buf = xmlBufferCreate();
        if (buf_data->buf == NULL) {
            DEBUG_STRING("xml_add", "Error creating the xml buffer");
            return ENOMEM;
        }
        DEBUG_NUMBER("Buffer allocated", buf_data->buf);
        DEBUG_NUMBER("Buffer output", (buf_data->buf)->content);

        /* Create a new XmlWriter for memory, with no compression.
         * Remark: there is no compression for this kind of xmlTextWriter */
        buf_data->writer = xmlNewTextWriterMemory(buf_data->buf, 0);
        if (buf_data->writer == NULL) {
            error = errno;
            DEBUG_STRING("xml_add", "Error creating the xml writer");
            xmlBufferFree(buf_data->buf);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return ENOMEM;
        }

        /* Start the document with the xml default for the version,
         * encoding and the default for the standalone declaration. */
        rc = xmlTextWriterStartDocument(buf_data->writer, NULL, NULL, NULL);
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterStartDocument");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }
        buf_data->given_name = NULL;
        buf_data->level = 0;
    }

    DEBUG_STRING("current buffer:", (buf_data->buf)->content);
    DEBUG_NUMBER("Writer", buf_data->writer);


    /* Check the beginning of the collection */
    if(type == ELAPI_TYPE_COLLECTION) {
        DEBUG_STRING("XML collection start: ", property);
        rc = xmlTextWriterStartElement(buf_data->writer, BAD_CAST ELEMENT_COLLECTION);
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterStartElement");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

        if(buf_data->given_name != NULL) name = buf_data->given_name;
        else name = property;
        rc = xmlTextWriterWriteAttribute(buf_data->writer, BAD_CAST ATTRIBUTE_NAME, BAD_CAST property);
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterWriteAttribute");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

        /* Make sure we track the level */
        buf_data->level++;
    }
    /* Check for subcollections */
    else if(type==ELAPI_TYPE_COLLECTIONREF) {
        buf_data->given_name = property;
    }
    /* Check for the end of the collection */
    else if(type==ELAPI_TYPE_END) {
        buf_data->given_name = NULL;
        buf_data->level--;
        /* Check if this is the end of the whole collection */
        if(buf_data->level == 0) {
            rc = xmlTextWriterEndDocument(buf_data->writer);
            if (rc < 0) {
                DEBUG_STRING("xml_add", "Error at xmlTextWriterEndDocument");
                xmlFreeTextWriter(buf_data->writer);
                xmlBufferFree(buf_data->buf);
                buf_data->writer = (xmlTextWriterPtr)(NULL);
                buf_data->buf = (xmlBufferPtr)(NULL);
                return EIO;
            }
        }
        else {
            rc = xmlTextWriterFullEndElement(buf_data->writer);
            if (rc < 0) {
                DEBUG_STRING("xml_add", "Error at xmlTextWriterEndElement");
                xmlFreeTextWriter(buf_data->writer);
                xmlBufferFree(buf_data->buf);
                buf_data->writer = (xmlTextWriterPtr)(NULL);
                buf_data->buf = (xmlBufferPtr)(NULL);
                return EIO;
            }
        }
    }
    else {
        DEBUG_STRING("Property: ", property);
        DEBUG_NUMBER("Property length: ", property_len);

        rc = xmlTextWriterStartElement(buf_data->writer, BAD_CAST ELEMENT_MEMBER);
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterStartElement");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

        rc = xmlTextWriterWriteAttribute(buf_data->writer, BAD_CAST ATTRIBUTE_NAME, BAD_CAST property);
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterWriteAttribute");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

        rc = xmlTextWriterWriteAttribute(buf_data->writer, BAD_CAST ATTRIBUTE_TYPE, BAD_CAST get_type(type));
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterWriteAttribute");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

        /* Add the value */

        switch(type) {
            case ELAPI_TYPE_STRING:
                                data_xml = (char *)(data);
                                if(!xmlCheckUTF8((const unsigned char *)(data_xml))) data_xml = BAD_DATA;
                                rc = xmlTextWriterWriteString(buf_data->writer, BAD_CAST data_xml);
                                break;
            case ELAPI_TYPE_BINARY:
                                rc = xmlTextWriterWriteBase64(buf_data->writer, (const char *)(data),0,length);
                                break;
            case ELAPI_TYPE_INTEGER:
                                rc = xmlTextWriterWriteFormatString(buf_data->writer, "%d", *((int *)(data)));
                                break;
            case ELAPI_TYPE_UNSIGNED:
                                rc = xmlTextWriterWriteFormatString(buf_data->writer, "%u", *((unsigned int *)(data)));
                                break;
            case ELAPI_TYPE_LONG:
                                rc = xmlTextWriterWriteFormatString(buf_data->writer, "%ld", *((long *)(data)));
                                break;
            case ELAPI_TYPE_ULONG:
                                rc = xmlTextWriterWriteFormatString(buf_data->writer, "%lu", *((unsigned long *)(data)));
                                break;
            case ELAPI_TYPE_DOUBLE:
                                rc = xmlTextWriterWriteFormatString(buf_data->writer, "%.4f", *((double *)(data)));
                                break;
            default:
                                rc = xmlTextWriterWriteString(buf_data->writer, BAD_CAST "");
                                break;
        }

        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error trying put data into XML");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

        rc = xmlTextWriterFullEndElement(buf_data->writer);
        if (rc < 0) {
            DEBUG_STRING("xml_add", "Error at xmlTextWriterFullEndElement");
            xmlFreeTextWriter(buf_data->writer);
            xmlBufferFree(buf_data->buf);
            buf_data->writer = (xmlTextWriterPtr)(NULL);
            buf_data->buf = (xmlBufferPtr)(NULL);
            return EIO;
        }

    } 

    DEBUG_STRING("xml_add","Exit point");
    return EOK;

}