gtask-stream-parser.c

Go to the documentation of this file.

#include <unistd.h>
#include <string.h>

#include <gtask/gtask-packet.h>
#include <gtask/gtask-error-packet.h>
#include <gtask/gtask-task-packet.h>
#include <gtask/gtask-watch-packet.h>
#include <gtask/gtask-remove-watch-packet.h>
#include <gtask-query-packet.h>
#include <gtask/gtask-file.h>

//#include <gtask/gtask-role-packet.h>

#include <gtask/gtask-stream-parser.h>

#include <gtask/gtask-internals.h>

/* @{ */

static gpointer parent_class;

static void
gtask_stream_parser_class_init( GTaskStreamParserClass *klass );

static void
gtask_stream_parser_init( GTaskStreamParser *parser );

static void
gtask_stream_parser_finalize( GObject *obj );

static void
gtask_stream_parser_dispose( GObject *obj );

static gboolean
gtask_stream_parser_init_parser( GTaskStreamParser *parser,
                                 char *buff,
                                 int len );

/* the actual SAX parsing callbacks and helpers */
static void
start_document( gpointer data );
    
static void
end_document( gpointer data );

static void
start_element( gpointer data,
               const xmlChar *name,
               const xmlChar **attrs );

static  void
end_element( gpointer data, const xmlChar *name );

static void
get_characters( gpointer data, const xmlChar *chars, int len );

static void
xml_warning( gpointer data, const char *msg, ... );

static void
xml_error( gpointer data, const char *msg, ... );

static void
xml_fatal_error( gpointer data, const char *msg, ... );


xmlSAXHandler sax_handler = {
    NULL, /* internalSubset */
    NULL, /* isStandalone */
    NULL, /* hasInternalSubset */
    NULL, /* hasExternalSubset */
    NULL, /* resolveEntity */
    NULL, /* getEntity */
    NULL, /* entityDecl */
    NULL, /* notationDecl */
    NULL, /* attributeDecl */
    NULL, /* elementDecl */
    NULL, /* unparsedEntityDecl */
    NULL, /* setDocumentLocator */
    start_document, /* startDocument */
    end_document, /* endDocument */
    start_element, /* startElement */
    end_element, /* endElement */
    NULL, /* reference */
    get_characters, /* characters */
    NULL, /* ignorableWhitespace */
    NULL, /* processingInstruction */
    NULL, /* comment */
    xml_warning, /* xmlParserWarning */
    xml_error, /* xmlParserError */
    xml_fatal_error, /* xmlParserError */
    NULL, /* getParameterEntity */
    NULL, /* cdataBlock; */
    NULL, /* externalSubset; */
    1,
    NULL,
    NULL, /* startElementNs */
    NULL, /* endElementNs */
    NULL  /* xmlStructuredErrorFunc */
};

typedef enum {
    DOCUMENT_LEVEL,
    STREAM_LEVEL,
    PACKET_LEVEL,
    PACKET_CONTENTS_LEVEL
} GTaskStreamParserLevel;

typedef enum {
    UNKNOWN,
    DOCUMENT_START
} GTaskStreamParserState;

typedef enum {
    NO_PACKET,
    ROLE,
    ERROR,
    WATCH,
    REMOVE_WATCH,
    TASK,
    QUERY
} GTaskStreamParserPacket;

typedef enum {
    NO_PROPERTY,

    PROP_CATEGORY,
    PROP_TITLE,

    PROP_PERCENT_COMPLETED,
    PROP_ACTIVITY_STATE,

    PROP_STATUS_MESSAGE,
    PROP_ERROR_MESSAGE,

    PROP_MIME_TYPE,
    PROP_RESULTANT_FILE_URI,
    PROP_THUMBNAIL_URI,

    PROP_TIME_LEFT
} GTaskStreamParserProperty;

struct _GTaskStreamParserPrivate {
    //  start parsing for packets
    gboolean                  received_header;

    int                       depth;
    int                       unknown_depth;

    GTaskStreamParserState    current_state;
    GTaskStreamParserState    previous_state;
 
    GTaskStreamParserError    parser_error;

    GTaskStreamParserPacket   curr_packet_type;
    GTaskStreamParserProperty curr_packet_prop;

    // Variables for the SAX Parser

    GTaskPacket      *curr_packet;

    GQueue           *packet_queue;

    xmlParserCtxtPtr  xml_context;

    char              init_buff[4];
    int               init_buff_rem;

    char              buff[4096];
    int               buff_loc;

    /*
    // Variables for the xmlTextReader parser

    xmlTextReaderPtr  xml_reader;

    xmlParserInputBufferPtr xml_buff;
    */

    gboolean            stream_eof;
    gboolean            dispose_has_run;
};

GType gtask_stream_parser_get_type( ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskStreamParserClass ),
            NULL,   /* base_init */
            NULL,   /* base_finalize */
            (GClassInitFunc )gtask_stream_parser_class_init,   /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskStreamParser ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_stream_parser_init
        };

        type = g_type_register_static( G_TYPE_OBJECT,
                                       "GTaskStreamParser",
                                       &info,
                                       0 );
    }

    return type;
}

/*
 * start of xml parser state machine code
 */

static void
xml_warning( gpointer data, const char *msg, ... ) {
    va_list args;

    va_start(args, msg);
    g_warning( "xml_warning" );
    g_warning( msg, args );
    va_end(args);
}

static void
xml_error( gpointer data, const char *msg, ... ) {
    GTaskStreamParser *parser = GTASK_STREAM_PARSER( data );
    va_list args;

    va_start(args, msg);
    g_error( "xml_error" );
    g_error( msg, args );
    va_end(args);
    parser->private->parser_error = GTASK_STREAM_PARSER_ERROR_SYNTAX_ERROR;
}

static void
xml_fatal_error( gpointer data, const char *msg, ... ) {
    GTaskStreamParser *parser = GTASK_STREAM_PARSER( data );
    va_list args;

    va_start(args, msg);
    g_error( "xml_fatal_error" );
    g_error( msg, args );
    va_end(args);

    parser->private->parser_error = GTASK_STREAM_PARSER_ERROR_SYNTAX_ERROR;
}

static void
start_document( gpointer data ) {
    GTaskStreamParser *parser = GTASK_STREAM_PARSER( data );
    GTaskStreamParserPrivate *private = parser->private;

//    g_debug( "start_document" );

    // initialize our parser (again just for kicks)
    private->received_header = FALSE;
    private->current_state = DOCUMENT_START;
    private->previous_state = UNKNOWN;
    private->depth = 0;
    private->unknown_depth = 0;

    private->parser_error = GTASK_STREAM_PARSER_ERROR_NONE;
}

static void
end_document( gpointer data ) {
    /* nothing to do here really */
}

static void
start_element( gpointer data,
               const xmlChar *name,
               const xmlChar **attrs )
{
    GTaskStreamParser        *parser = GTASK_STREAM_PARSER( data );
    GTaskStreamParserPrivate *private = parser->private;
    int               i;

//    g_debug( "start_element: %d, %s", private->depth, name );

    private->depth++;
    private->buff_loc = 0;

    if( private->current_state == UNKNOWN ) {
        private->unknown_depth++;

        return;
    }

    if( private->depth == STREAM_LEVEL ) {
        if( strcmp( name, "gtask-stream" ) != 0 )
            private->parser_error = GTASK_STREAM_PARSER_ERROR_SYNTAX_ERROR;
        else
            private->received_header = TRUE;
    } else if( private->depth == PACKET_LEVEL ) {
        if( strcmp( name, "task" ) == 0 ) {
            const char *app = NULL;
            const char *id = NULL;

            GTaskTaskPacket  *packet;
            GTaskGenericTask *task = gtask_generic_task_new( );

            for( i = 0; attrs[i]; i++ ) {
                if( strcmp( attrs[i], "application" ) == 0 ) {
                    app = attrs[i+1];
                } else if( strcmp( attrs[i], "id" ) == 0 ) {
                    id = attrs[i+1];
                }
            }

            /* these two elements are required */
            if( !app && !id ) {
                private->parser_error = GTASK_STREAM_PARSER_ERROR_SYNTAX_ERROR;
                return;
            }

            task = gtask_generic_task_new( );
            gtask_generic_task_set_application( task, app );
            gtask_generic_task_set_id( task, id );

            private->curr_packet_type = TASK;

            packet = gtask_task_packet_new_with_task( task );
            g_object_unref( task );

            packet = gtask_task_packet_new_with_task( task );

            private->curr_packet = GTASK_PACKET( packet );
        } else if( strcmp( name, "role" ) == 0 ) {
            g_warning( "GTaskRole packets no longer supported" );
//            private->curr_packet_type = ROLE;
//            private->curr_packet = GTASK_PACKET( gtask_role_packet_new( ) );
        } else if( strcmp( name, "error" ) == 0 ) {
            const char       *type = NULL;

            for( i = 0; attrs[i]; i++ ) {
                if( strcmp( attrs[i], "type" ) == 0 ) {
                    type = attrs[i+1];
                }
            }

            if( !type ) {
                /* set unknown error type */
            }

            private->curr_packet_type = ERROR;
            private->curr_packet = GTASK_PACKET( gtask_error_packet_new( ) );
        } else if( strcmp( name, "watch" ) == 0 ) {
            const char       *id = NULL;
            GTaskWatchPacket *packet;
            
            for( i = 0; attrs[i]; i++ ) {
                if( strcmp( attrs[i], "id" ) == 0 ) {
                    id = attrs[i+1];
                }
            }

            if( !id ) {
                private->parser_error = GTASK_STREAM_PARSER_ERROR_SYNTAX_ERROR;

                return;
            }

            private->curr_packet_type = WATCH;
            packet = gtask_watch_packet_new_with_watch_id( id );

            private->curr_packet = GTASK_PACKET( packet );
        } else if( strcmp( name, "remove-watch" ) == 0 ) {
            const char             *id = NULL;
            GTaskRemoveWatchPacket *packet;

            for( i = 0; attrs[i]; i++ ) {
                if( strcmp( attrs[i], "id" ) == 0 ) {
                    id = attrs[i+1];
                }
            }

            if( !id ) {
                private->parser_error = GTASK_STREAM_PARSER_ERROR_SYNTAX_ERROR;
                return;
            }

            packet = gtask_remove_watch_packet_new_with_watch_id( id );
            private->curr_packet_type = REMOVE_WATCH;
            private->curr_packet = GTASK_PACKET( packet );
        } else if( strcmp( name, "query" ) == 0 ) {
            GTaskQueryPacket *packet;

            packet = gtask_query_packet_new( );

            private->curr_packet_type = QUERY;
            private->curr_packet = GTASK_PACKET( packet );
        } else {
            /* skip over unknown elements and their subtrees */
            private->curr_packet_type = NO_PACKET;
            private->previous_state = private->current_state;
            private->current_state = UNKNOWN;
        }
    } else if( private->depth == PACKET_CONTENTS_LEVEL ) {
        switch( private->curr_packet_type ) {
            case TASK:
                if( strcmp( name, "category" ) == 0 ) {
                    private->curr_packet_prop = PROP_CATEGORY;
                } else if( strcmp( name, "title" ) == 0 ) {
                    private->curr_packet_prop = PROP_TITLE;
                } else if( strcmp( name, "percent-completed" ) == 0 ) {
                    private->curr_packet_prop = PROP_PERCENT_COMPLETED;
                } else if( strcmp( name, "status-message" ) == 0 ) {
                    private->curr_packet_prop = PROP_STATUS_MESSAGE;
                } else if( strcmp( name, "error-message" ) == 0 ) {
                    private->curr_packet_prop = PROP_ERROR_MESSAGE;
                } else if( strcmp( name, "thumbnail-uri" ) == 0 ) {
                    private->curr_packet_prop = PROP_THUMBNAIL_URI;
                } else if( strcmp( name, "resultant-file-uri" ) == 0 ) {
                    private->curr_packet_prop = PROP_RESULTANT_FILE_URI;
                } else if( strcmp( name, "activity-state" ) == 0 ) {
                    private->curr_packet_prop = PROP_ACTIVITY_STATE;
                } else if( strcmp( name, "time-left" ) == 0 ) {
                    private->curr_packet_prop = PROP_TIME_LEFT;
                } else if( strcmp( name, "file" ) == 0 ) {
                    GTaskGenericTask *task = gtask_task_packet_get_task( GTASK_TASK_PACKET( private->curr_packet ) );
                    GTaskFile        *file;

                    const char *uri = NULL;
                    const char *thumb_uri = NULL;
                    const char *mime_type = NULL;
                    const char *description = NULL;
                    gboolean    completed = FALSE;

                    for( i = 0; attrs[i]; i++ ) {
                        if( strcmp( attrs[i], "uri" ) == 0 ) {
                            uri = attrs[i+1];
                        } else if( strcmp( attrs[i], "thumbnail-uri" ) == 0 ) {
                            thumb_uri = attrs[i+1];
                        } else if( strcmp( attrs[i], "mime-type" ) == 0 ) {
                            mime_type = attrs[i+1];
                        } else if( strcmp( attrs[i], "description" ) == 0 ) {
                            description = attrs[i+1];
                        } else if( strcmp( attrs[i], "completed" ) == 0 ) {
                            completed = ( atoi( attrs[i+1] ) > 0 ) ? TRUE : FALSE;
                        }
                    }

                    file = gtask_file_new_with_properties( uri, mime_type, thumb_uri, description );

                    gtask_file_set_completed( file, completed );

                    gtask_generic_task_add_file( task, file );

                    g_object_unref( file );
                } else {
                    private->curr_packet_prop = NO_PROPERTY;
                }
                break;
            default:
                break;
        }
    }
}

static void
end_element( gpointer data, const xmlChar *name ) {
    GTaskStreamParser        *parser = GTASK_STREAM_PARSER( data );
    GTaskStreamParserPrivate *private = parser->private;

//    g_debug( "end_element: %d %s", private->depth, name );

    if( private->current_state == UNKNOWN ) {
        if( private->unknown_depth-- == 0 ) {
            private->current_state = private->previous_state;
        }

        goto DEC_DEPTH;
    }

    if( private->depth == STREAM_LEVEL  ) {
        /* the only element that can be here is a closing gtask-stream
         * since the error handlers would have kicked in if it were anything
         * else, so just mark the stream as being closed */
//        g_debug( "received ending gtask-stream, setting stream_eof" );
        private->stream_eof = TRUE;
    } else if( private->depth == PACKET_LEVEL ) {
        GTaskPacket *curr_packet = private->curr_packet;
        char        *buff = private->buff;

        /* do nothing if we are not currently constructing a packet */
        if( !curr_packet )
            goto DEC_DEPTH;

        /* copy of our character data for any of our packets without
         * any explicit properties */
        switch( private->curr_packet_type ) {
            /*
            case ROLE:
                gtask_role_packet_set_role_from_name( GTASK_ROLE_PACKET( curr_packet ), buff );
                break;
                */
            case ERROR:
                gtask_error_packet_set_error_message( GTASK_ERROR_PACKET( curr_packet ), buff );
            default:
                break;
        }

        /* place the current packet, if any into the queue */
        if( curr_packet ) {
//            g_debug( "adding the current packet to the queue: %s", G_OBJECT_TYPE_NAME( curr_packet ) );
            g_queue_push_tail( private->packet_queue, curr_packet );

            private->curr_packet = NULL;
        }

        private->curr_packet_type = NO_PACKET;
        private->curr_packet_prop = NO_PROPERTY;
    } else if( private->depth == PACKET_CONTENTS_LEVEL ) {
        GTaskPacket *curr_packet = private->curr_packet;
        GTaskGenericTask *task;
        char        *buff = private->buff;
        float        perc;

        g_strdelimit( buff, "\r\n", ' ' );
        g_strstrip( buff );

        switch( private->curr_packet_type ) {
            case TASK:
                task = gtask_task_packet_get_task( GTASK_TASK_PACKET( curr_packet ) );

                switch( private->curr_packet_prop ) {
                    case PROP_CATEGORY:
                        gtask_generic_task_set_category( task, buff );
                        break;
                    case PROP_PERCENT_COMPLETED:
                        perc = atof( buff );

                        if( perc <  0 )
                            perc = -perc;

                        gtask_generic_task_set_percent_done( task, perc );
                        break;
                    case PROP_TIME_LEFT:
                        g_debug( "================> %s : %ld", buff, atol( buff ) );
                        if( gtask_generic_task_get_time_left( task ) <= 0 )
                            gtask_generic_task_set_time_left( task, atol( buff ) );
                        break;
                    case PROP_TITLE:
                        gtask_generic_task_set_title( task, buff );
                        break;
                    case PROP_STATUS_MESSAGE:
                        gtask_generic_task_set_status_message( task, buff );
                        break;
                    case PROP_ACTIVITY_STATE:
                        gtask_generic_task_set_activity_state_from_string( task,
                                                                         buff );
                        break;
                    case PROP_ERROR_MESSAGE:
                        gtask_generic_task_set_error_message( task, buff );
                        break;
                    case PROP_THUMBNAIL_URI:
                        gtask_generic_task_set_thumbnail_uri( task, buff );
                        break;
                    default:
                        break;
                }

                break;
            default:
                break;
        }
    }

DEC_DEPTH:
    private->depth--;
    
    // reset the char array to the beginning,
    // technically this is incorrect since we need to keep
    // a bunch of these to amalgamate junk for each level, but for
    // now screw it
    parser->private->buff_loc = 0;
}

static void
get_characters( gpointer data, const xmlChar *chars, int len ) {
    GTaskStreamParser *parser = GTASK_STREAM_PARSER( data );
    char              *buff = parser->private->buff;
    int               *buff_loc = &parser->private->buff_loc;
    int                space;

//    g_debug( "get_characters: length: %d | buffer_location: %d", len, *buff_loc );

    buff[ *buff_loc ] = '\0';

    space = 4096 - *buff_loc - 1 ;

    if( len > space )
        len = space;

    strncat( buff + *buff_loc, chars, len );

    *buff_loc += *buff_loc + len;

    buff[ *buff_loc ] = '\0';
}


/*
 * end of xml parser state machine code
 */

static void
gtask_stream_parser_class_init( GTaskStreamParserClass *klass ) {
    GObjectClass *gobject_class = G_OBJECT_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->dispose = gtask_stream_parser_dispose;
    gobject_class->finalize = gtask_stream_parser_finalize;
}

static void
gtask_stream_parser_init( GTaskStreamParser *parser ) {
    GTaskStreamParserPrivate *private;

    private = g_new0( GTaskStreamParserPrivate, 1 );

    parser->private = private;

    private->packet_queue = g_new0( GQueue, 1 );

    private->parser_error = GTASK_STREAM_PARSER_ERROR_NONE;
    private->stream_eof = FALSE;

    private->received_header = FALSE;

    private->current_state = UNKNOWN;
    private->previous_state = UNKNOWN;
    private->depth = 0;
    private->unknown_depth = 0;
    private->buff_loc = 0;

    private->curr_packet_type = NO_PACKET;
    private->dispose_has_run = FALSE;
}

static void
gtask_stream_parser_dispose( GObject *obj ) {
    GTaskStreamParser        *parser = GTASK_STREAM_PARSER( obj );
    GTaskStreamParserPrivate *private = parser->private;
    gpointer                  item = NULL;

    if( private->dispose_has_run )
        return;

    while( ( item = g_queue_pop_head( private->packet_queue ) ) ) {
        GTaskPacket *packet = GTASK_PACKET( item );

        g_object_unref( packet );
    }

    private->dispose_has_run = TRUE;

    if( G_OBJECT_CLASS( parent_class )->dispose )
        G_OBJECT_CLASS( parent_class )->dispose( obj );
}

static void
gtask_stream_parser_finalize( GObject *obj ) {
    GTaskStreamParser        *parser = GTASK_STREAM_PARSER( obj );
    GTaskStreamParserPrivate *private = parser->private;

    g_queue_free( private->packet_queue );

    // Free our xml-foo
    xmlFreeParserCtxt( private->xml_context );

    g_free( parser->private );

    if( G_OBJECT_CLASS( parent_class )->finalize )
        G_OBJECT_CLASS( parent_class )->finalize( obj );
}

GTaskStreamParser *
gtask_stream_parser_new( ) {
    return g_object_new( GTASK_STREAM_PARSER_TYPE, NULL );
}

static gboolean
gtask_stream_parser_init_parser( GTaskStreamParser *parser,
                                 char *buff,
                                 int len )
{
    xmlParserCtxtPtr xml_context;

    if( parser->private->xml_context )
        return TRUE;

    //xml_context = xmlCreatePushParserCtxt( &sax_handler, parser, buff, len, NULL );
    xml_context = xmlCreatePushParserCtxt( &sax_handler, parser, NULL, 0, "test-stream" );

    if( !xml_context )
        return FALSE;

    parser->private->xml_context = xml_context;

    return TRUE;
}

gboolean
gtask_stream_parser_has_packets( GTaskStreamParser *parser ) {
    g_return_val_if_fail( GTASK_IS_STREAM_PARSER( parser ), FALSE );
    g_return_val_if_fail( !parser->private->dispose_has_run, FALSE );

    return ( !g_queue_is_empty( parser->private->packet_queue ) );
}

gboolean
gtask_stream_parser_push_data( GTaskStreamParser *parser,
                               char *buff,
                               int len )
{
    g_return_val_if_fail( GTASK_IS_STREAM_PARSER( parser ), FALSE );
    g_return_val_if_fail( !parser->private->dispose_has_run, TRUE );

    g_debug( "IN: gtask_stream_parser_push_data" );

    if( !parser->private->xml_context ) {
//        if( len < 4 ) {
//            g_error( "for the moment the push_data requires art least "
//                     "4 bytes of data for its first call" );
//        }

        g_debug( "pusing first 4 bytes to the parser for init" );
        if( !gtask_stream_parser_init_parser( parser, buff, 4 ) ) {
            g_error( "Unable to initialize the parser\n" );
            g_debug( "LEAVING: gtask_stream_parser_push_data - unable to init parser" );
            return FALSE;
        }

        /* skip past what was just sent to the parser */
//        buff += 4;
//        len -= 4;
    }

    g_debug( "pushing %d bytes of data to the parser: %s", len, buff );
    xmlParseChunk( parser->private->xml_context, buff, len, 0 );
    g_debug( "done" );

    g_debug( "LEAVING: gtask_stream_parser_push_data" );

    return ( parser->private->parser_error == GTASK_STREAM_PARSER_ERROR_NONE );
}

GObject *
gtask_stream_parser_get_next_packet( GTaskStreamParser *parser ) {
    GTaskStreamParserPrivate *private;
    GQueue                   *packet_queue;

    g_return_val_if_fail( GTASK_IS_STREAM_PARSER( parser ), NULL );
    g_return_val_if_fail( !parser->private->dispose_has_run, NULL );

    g_debug( "IN: gtask_stream_parser_get_next_packet" );

    private = parser->private;
    packet_queue = private->packet_queue;

    if( !g_queue_is_empty( packet_queue ) ) {
        g_debug( "LEAVING: gtask_stream_parser_get_next_packet - got packet" );
        return G_OBJECT( g_queue_pop_head( packet_queue ) );
        //return GTASK_PACKET( g_queue_pop_head( packet_queue ) );
    }

    g_debug( "LEAVING: gtask_stream_parser_get_next_packet - no packet" );

    return NULL;
}

gboolean
gtask_stream_parser_has_error( GTaskStreamParser *parser ) {
    g_return_val_if_fail( GTASK_IS_STREAM_PARSER( parser ), TRUE );
    g_return_val_if_fail( !parser->private->dispose_has_run, FALSE );

    return ( parser->private->parser_error != GTASK_STREAM_PARSER_ERROR_NONE );
}

void
gtask_stream_parser_reset_state( GTaskStreamParser *parser ) {
    GTaskStreamParserPrivate *private;

    g_return_if_fail( GTASK_IS_STREAM_PARSER( parser ) );

    g_debug( "IN: gtask_stream_parser_reset_state" );

    private = parser->private;

    private->parser_error = GTASK_STREAM_PARSER_ERROR_NONE;
    private->stream_eof = FALSE;

    private->received_header = FALSE;

    private->current_state = UNKNOWN;
    private->previous_state = UNKNOWN;
    private->depth = 0;
    private->unknown_depth = 0;
    private->buff_loc = 0;

    private->curr_packet_type = NO_PACKET;

    g_debug( "LEAVING: gtask_stream_parser_reset_state" );
}

/* @} */

---