gtask-connection.c

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#include <unistd.h>
#include <fcntl.h>

#include <gtask/gtask-connection.h>

#include "gtask-internals.h"

/* @{ */

enum {
    PROP_0,
    PROP_NAME,
    PROP_ROLE,
    PROP_STREAM_PARSER,
    PROP_EVENT_PARSER
};

static gpointer parent_class;

static gboolean
gtask_connection_write( GTaskConnection *conn, char *buff );

static void
gtask_connection_class_init( GTaskConnectionClass *klass );

static void
gtask_connection_init( GTaskConnection *connection, gpointer g_class );

static void
gtask_connection_finalize( GObject *obj );

static gboolean
gtask_connection_init_xml_buffers( GTaskConnection *conn );

static gboolean
gtask_connection_init_gio_channels( GTaskConnection *conn );

static void
gtask_connection_set_property( GObject *object,
                               guint param_id,
                               const GValue *value,
                               GParamSpec *pspec  );

static void
gtask_connection_get_property( GObject *object,
                               guint param_id,
                               GValue *value,
                               GParamSpec *pspec  );

GType gtask_role_get_type( ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GEnumValue values[] = {
            { GTASK_ROLE_NONE, "GTASK_ROLE_NONE", "none" },
            { GTASK_ROLE_NONE, "GTASK_ROLE_PROXY", "proxy" },
            { GTASK_ROLE_NONE, "GTASK_ROLE_REPORTER", "reporter" },
            { GTASK_ROLE_NONE, "GTASK_ROLE_PROVIDER", "provider" },
            { 0, NULL, NULL }
        };

        type = g_enum_register_static( "GTaskRole", values );
    }

    return type;
}

GType gtask_connection_get_type( void ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskConnectionClass ),
            NULL,   /* base init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_connection_class_init,   /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskConnection ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_connection_init
        };

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

    return type;
}

static void
gtask_connection_class_init( GTaskConnectionClass *klass ) {
    GObjectClass *gobject_class = G_OBJECT_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->finalize = gtask_connection_finalize;
    gobject_class->set_property = gtask_connection_set_property;
    gobject_class->get_property = gtask_connection_get_property;

    klass->connected_signal_id = g_signal_newv( "connected",
                                                G_TYPE_FROM_CLASS( klass ),
                                                G_SIGNAL_RUN_LAST |
                                                  G_SIGNAL_NO_RECURSE |
                                                  G_SIGNAL_NO_HOOKS,
                                                NULL,
                                                NULL,
                                                NULL,
                                                g_cclosure_marshal_VOID__VOID,
                                                G_TYPE_NONE,
                                                0,
                                                NULL );

    klass->disconnected_signal_id = g_signal_newv( "disconnected",
                                                G_TYPE_FROM_CLASS( klass ),
                                                G_SIGNAL_RUN_LAST |
                                                  G_SIGNAL_NO_RECURSE |
                                                  G_SIGNAL_NO_HOOKS,
                                                NULL,
                                                NULL,
                                                NULL,
                                                g_cclosure_marshal_VOID__VOID,
                                                G_TYPE_NONE,
                                                0,
                                                NULL );

    g_object_class_install_property( gobject_class,
                                     PROP_NAME,
                                     g_param_spec_string( "name",
                                                          "Name",
                                                          "The name of the connection.",
                                                          "-unamed-",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( gobject_class,
                                     PROP_ROLE,
                                     g_param_spec_enum( "role",
                                                        "Role",
                                                        "The GTaskRole of the connection. This item should be set before a connection is connected.",
                                                        GTASK_ROLE_TYPE,
                                                        GTASK_ROLE_NONE,
                                                        G_PARAM_READWRITE ) );
}

static void
gtask_connection_set_property( GObject *object,
                               guint param_id,
                               const GValue *value,
                               GParamSpec *pspec  )
{
    GTaskConnection *conn = GTASK_CONNECTION( object );

    switch( param_id ) {
        case PROP_NAME:
            gtask_connection_set_name( conn, g_value_get_string( value ) );
            break;
        case PROP_ROLE:
            gtask_connection_set_role( conn, g_value_get_enum( value ) );
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
    }
}

static void
gtask_connection_get_property( GObject *object,
                               guint param_id,
                               GValue *value,
                               GParamSpec *pspec  )
{
    GTaskConnection *conn = GTASK_CONNECTION( object );

    switch( param_id ) {
        case PROP_NAME:
            g_value_set_string( value, gtask_connection_get_name( conn ) );
            break;
        case PROP_ROLE:
            g_value_set_enum( value, gtask_connection_get_role( conn ) );
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
    }
}

static gboolean
gtask_connection_write( GTaskConnection *conn, char *buff ) {
    int fd = gtask_connection_get_output_fd( conn );

    int len = strlen( buff );

    while( len ) {
        int ret = write( fd, buff, len );

        if( ret < 1 )
            return FALSE;
        
        len -= ret;
    }

    return TRUE;
}

static void
gtask_connection_init( GTaskConnection *connection, gpointer g_class ) {
    GTaskConnectionPrivate *private;

    private = g_new0( GTaskConnectionPrivate, 1 );

    private->inp_fd = -1;
    private->out_fd = -1;
    private->name = g_string_new( "-unamed-" );

    private->role = GTASK_ROLE_NONE;
    private->parser = gtask_stream_parser_new( );
    private->dispatcher = gtask_event_dispatcher_new_with_parser( private->parser );

    private->conn_method = GTASK_CONNECTION_METHOD_UNKNOWN;
    private->socket_uri = NULL;

    private->auto_reconnect = TRUE;
    private->auto_parse = TRUE;

    connection->private = private;
}

GTaskConnection *
gtask_connection_new( ) {
    return g_object_new( GTASK_CONNECTION_TYPE, NULL );
}

GTaskConnection *
gtask_connection_new_with_properties( const gchar *name, GTaskRole role ) {
    GTaskConnection *conn = gtask_connection_new( );

    if( name )
        gtask_connection_set_name( conn, name );

    gtask_connection_set_role( conn, role );

    return conn;
}

gchar *
gtask_connection_default_server_bind_path( ) {
    return g_strdup_printf( "%s/.gtaskd/server/socket", g_get_home_dir( ) );
}

gboolean
gtask_connection_connect_domain_socket_default( GTaskConnection *conn ) {
    char     *location;
    gboolean  ret;

    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );
    g_return_val_if_fail( !gtask_connection_is_connected( conn ), FALSE );

    location = gtask_connection_default_server_bind_path( );

    ret = gtask_connection_connect_domain_socket( conn, location );

    g_free( location );

    return ret;
}

gboolean
gtask_connection_connect_domain_socket( GTaskConnection *conn,
                                        const char *file )
{
    GTaskConnectionPrivate *private;
    struct sockaddr_un      sock_un;
    int                     fd;

    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );
    g_return_val_if_fail( !gtask_connection_is_connected( conn ), FALSE );

    private = conn->private;

    fd = socket( AF_LOCAL, SOCK_STREAM, 0 );

    if( fd < 0 ) {
        g_warning( "Error creating socket" );
        return FALSE;
    }

    bzero( &sock_un, sizeof( sock_un ) );
    sock_un.sun_family = AF_LOCAL;
    strncpy( sock_un.sun_path, file, sizeof( sock_un.sun_path ) - 1 );

    if( connect( fd, (struct sockaddr *) &sock_un, sizeof( sock_un ) ) < 0 ) {
        g_warning( "Error on connect" );
        close( fd );
        return FALSE;
    }

    private->conn_method = GTASK_CONNECTION_METHOD_SOCKET;
    
    g_free( private->socket_uri );
    private->socket_uri = g_strdup( file );

    if( !gtask_connection_connect_fd( conn, fd, fd ) ) {
        close( fd );
        return FALSE;
    }

    return TRUE;
}

gboolean
gtask_connection_connect_loopback( GTaskConnection *conn ) {
    int      fd[2];

    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );
    g_return_val_if_fail( !gtask_connection_is_connected( conn ), FALSE );

    if( pipe( fd ) < 0 ) {
        g_warning( "error creating pipe" );

        return FALSE;
    }

    conn->private->conn_method = GTASK_CONNECTION_METHOD_LOOPBACK;

    shutdown( fd[0], 0 );
    shutdown( fd[1], 1 );

    if( !gtask_connection_connect_fd( conn, fd[0], fd[1] ) ) {
        close( fd[0] );
        close( fd[1] );

        return FALSE;
    }

    return TRUE;
}

static gboolean
gtask_connection_init_xml_buffers( GTaskConnection *conn ) {
    GTaskConnectionPrivate *private = conn->private;

    g_return_val_if_fail( private->inp_fd >= 0, FALSE );
    g_return_val_if_fail( private->out_fd >= 0, FALSE );
    g_return_val_if_fail( !private->xml_output, FALSE );

    private->xml_output = xmlOutputBufferCreateFd( private->out_fd,
                                                   XML_CHAR_ENCODING_NONE );

    if( !private->xml_output )
        return FALSE;

    return TRUE;
}

static gboolean
gtask_connection_init_gio_channels( GTaskConnection *conn ) {
    GTaskConnectionPrivate *private = conn->private;
    int                     status;
    int                     flags;

    g_return_val_if_fail( private->inp_fd >= 0, FALSE );
    g_return_val_if_fail( !private->g_input, FALSE );

    private->g_input = g_io_channel_unix_new( private->inp_fd );

    g_io_channel_set_encoding( private->g_input, NULL, NULL );
    g_io_channel_set_buffered( private->g_input, FALSE );

    flags = g_io_channel_get_flags( private->g_input );

    status = g_io_channel_set_flags( private->g_input,
                                     flags & G_IO_FLAG_NONBLOCK,
                                     NULL );

    if( status != G_IO_STATUS_NORMAL ) {
        g_io_channel_unref( private->g_input );
        private->g_input = NULL;

        return FALSE;
    }

    return TRUE;
}

/*
 * this is called if the input source is disconnected
 */
static gboolean
gtask_connection_connection_broken( GIOChannel *source,
                                    GIOCondition cond,
                                    gpointer data )
{
    if( cond == G_IO_HUP ) {
        GTaskConnection *conn = GTASK_CONNECTION( data );

        conn->private->g_hup_source_id = 0;

        gtask_connection_close( conn );

        g_warning( "connection to server broken, closing it down" );

        if( conn->private->auto_parse )
            gtask_stream_parser_reset_state( conn->private->parser );

        g_signal_emit( conn,
                     GTASK_CONNECTION_GET_CLASS( conn )->disconnected_signal_id,
                     0,
                     NULL );
        
        g_warning( "we would attempt to reconnect here" );
    } else {
        g_warning( "gtask_connection_connection_broken called, but the GIOCondition != G_IO_HUP" );
    }

    return FALSE;
}

gboolean
gtask_connection_connect_fd( GTaskConnection *conn, int inp_fd, int out_fd ) {
    GTaskConnectionPrivate *private = conn->private;

    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );
    g_return_val_if_fail( !gtask_connection_is_connected( conn ), FALSE );

    private->inp_fd = inp_fd;
    private->out_fd = out_fd;

    if( !gtask_connection_init_xml_buffers( conn ) ) {
        private->inp_fd = -1;
        private->out_fd = -1;

        return FALSE;
    }

    if( !gtask_connection_init_gio_channels( conn ) ) {
        xmlOutputBufferClose( private->xml_output );
        private->inp_fd = -1;
        private->out_fd = -1;
        private->xml_output = NULL;

        return FALSE;
    }

    if( !gtask_connection_write( conn, "<gtask-stream>" ) ) {
        xmlOutputBufferClose( private->xml_output );
        private->xml_output = NULL;

        g_io_channel_unref( private->g_input );
        private->g_input = NULL;

        private->inp_fd = -1;
        private->out_fd = -1;
        
        return FALSE;
    }

    if( private->conn_method == GTASK_CONNECTION_METHOD_UNKNOWN )
        private->conn_method = GTASK_CONNECTION_METHOD_FD;

    g_debug( "==> Emitting connected signal" );

    g_signal_emit( conn,
                   GTASK_CONNECTION_GET_CLASS( conn )->connected_signal_id,
                   0,
                   NULL );

    if( private->auto_parse ) {
        private->g_in_source_id = g_io_add_watch( private->g_input,
                                  G_IO_IN,
                                  gtask_event_dispatcher_private_parse_callback,
                                  private->dispatcher ); 
    }

    /* @todo watch output for disconnects too? */
    private->g_hup_source_id = g_io_add_watch( private->g_input,
                                             G_IO_HUP,
                                             gtask_connection_connection_broken,
                                             conn );
    return TRUE;
}

gboolean
gtask_connection_is_connected( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );

    return ( conn->private->inp_fd >= 0 && conn->private->out_fd >= 0 );
}


static void
gtask_connection_finalize( GObject *obj ) {
    GTaskConnection *conn = GTASK_CONNECTION( obj );

    gtask_connection_close( conn );

    g_free( conn->private );

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

gint
gtask_connection_get_input_fd( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), -1 );

    return conn->private->inp_fd;
}

gint
gtask_connection_get_output_fd( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), -1 );

    return conn->private->out_fd;
}

gboolean
gtask_connection_close( GTaskConnection *conn ) {
    GTaskConnectionPrivate *private;
    gboolean                same;

    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );

    private = conn->private;

    same = ( private->inp_fd == private->out_fd );

    if( private->g_hup_source_id ) {
        g_source_remove( private->g_hup_source_id );
        private->g_hup_source_id = 0;
    }

    if( private->g_in_source_id ) {
        g_source_remove( private->g_in_source_id );
        private->g_in_source_id = 0;
    }

    if( private->xml_output ) {
        xmlOutputBufferClose( private->xml_output );
        private->xml_output = NULL;
    }

    if( private->g_input ) {
        g_io_channel_unref( private->g_input );
        private->g_input = NULL;
    }

    if( private->inp_fd > -1 ) {
        close( private->inp_fd );

        private->inp_fd = -1;
    }

    if( !same && private->out_fd > -1 ) {
        close( private->out_fd );

        private->out_fd = -1;
    }

    return TRUE;
}

GIOChannel *
gtask_connection_get_gio_input_channel( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), NULL );

    return conn->private->g_input;
}

xmlOutputBufferPtr
gtask_connection_get_xml_output_buffer( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), NULL );

    return conn->private->xml_output;
}


const gchar *
gtask_connection_get_name( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), "" );

    return conn->private->name->str;
}

void
gtask_connection_set_name( GTaskConnection *conn, const gchar *name ) {
    g_return_if_fail( GTASK_IS_CONNECTION( conn ) );
    g_return_if_fail( name != NULL );

    g_string_assign( conn->private->name, name );

    g_object_notify( (GObject *) conn, "name" );
}

GTaskRole
gtask_connection_get_role( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), GTASK_ROLE_NONE );

    return conn->private->role;
}

void
gtask_connection_set_role( GTaskConnection *conn, GTaskRole role ) {
    g_return_if_fail( GTASK_IS_CONNECTION( conn ) );

    conn->private->role = role;

    g_object_notify( (GObject *) conn, "role" );
}

GTaskStreamParser *
gtask_connection_get_stream_parser( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), NULL );

    return conn->private->parser;
}

GTaskEventDispatcher *
gtask_connection_get_event_dispatcher( GTaskConnection *conn ) {
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), NULL );

    return conn->private->dispatcher;
}

/* @} */

---