xdgmime.c

台湾人开发的Linux下的文件管理器

const char *
xdg_mime_get_mime_type_for_file ( const char *file_path,
                                  const char *base_name,
                                  struct stat *statbuf )
{
    const char *mime_type;
    /* currently, only a few globs occur twice, and none
     * more often, so 5 seems plenty.
     */
    const char *mime_types[ 5 ];
    int file;
    unsigned char data[ 256 ];
    int max_extent;
    int bytes_read;
    struct stat buf;
    int n;

    if ( file_path == NULL )
        return NULL;

    /*
    2006.01.07 modified by Hong Jen Yee
    if (! _xdg_utf8_validate (file_path))
      return NULL;
    */
    if ( _caches )
        return _xdg_mime_cache_get_mime_type_for_file ( file_path, statbuf );

    if ( !base_name )
        base_name = _xdg_get_base_name ( file_path );
    n = _xdg_glob_hash_lookup_file_name ( global_hash, base_name, mime_types, 5 );

    if ( n >= 1 && mime_types[ 0 ] && *mime_types[ 0 ] )
        return mime_types[ 0 ];

    if ( !statbuf )
    {
        if ( stat ( file_path, &buf ) != 0 )
            return XDG_MIME_TYPE_UNKNOWN;
        statbuf = &buf;
    }
    if ( S_ISDIR( statbuf->st_mode ) )
        return XDG_MIME_TYPE_DIRECTORY;

    if ( !S_ISREG ( statbuf->st_mode ) )
        return XDG_MIME_TYPE_UNKNOWN;

    /* FIXME: Need to make sure that max_extent isn't totally broken.  This could
     * be large and need getting from a stream instead of just reading it all
     * in. */
    /*
    max_extent = _xdg_mime_magic_get_buffer_extents (global_magic);
    data = malloc (max_extent);
    if (data == NULL)
      return XDG_MIME_TYPE_UNKNOWN;
    */

    file = open ( file_path, O_RDONLY );
    if ( file == -1 )
    {
        /* free (data); */
        return XDG_MIME_TYPE_UNKNOWN;
    }

    bytes_read = read ( file, data, sizeof( data ) );
    if ( bytes_read == -1 )
    {
        close ( file );
        return XDG_MIME_TYPE_UNKNOWN;
    }
    close ( file );

    mime_type = _xdg_mime_magic_lookup_data ( global_magic, data, bytes_read,
                                              mime_types, n );

    /* 2005.01.07 modified by Hong Jen Yee */
    /* Fallback for text files */
    if ( !mime_type )
    {
        for ( n = 0; n < bytes_read; ++n )
        {
            if ( data[ n ] == '\0' )
                break;
        }
        if ( n >= bytes_read )
        {
            mime_type = XDG_MIME_TYPE_PLAIN_TEXT;
        }
    }

    if ( mime_type )
        return mime_type;

    return XDG_MIME_TYPE_UNKNOWN;
}

const char*
xdg_mime_get_mime_type_from_file_name ( const char *file_name )
{
    const char* mime_types[ 2 ];

    if ( _caches )
        return _xdg_mime_cache_get_mime_type_from_file_name ( file_name );

    if ( _xdg_glob_hash_lookup_file_name ( global_hash, file_name, mime_types, 2 ) == 1
            && mime_types[ 0 ] && *mime_types[ 0 ] )
        return mime_types[ 0 ];
    else
        return XDG_MIME_TYPE_UNKNOWN;
}

int
xdg_mime_is_valid_mime_type ( const char *mime_type )
{
    /* FIXME: We should make this a better test
     */ 
    return _xdg_utf8_validate ( mime_type );
}

void
xdg_mime_shutdown ( void )
{
    GSList* l;

    for ( l = monitor_list; l; l = l->next )
    {
	if ( l->data )
            vfs_file_monitor_remove( ( VFSFileMonitor* ) l->data,
                                     xdg_mime_file_changed, NULL );
    }
    g_slist_free( monitor_list );
    monitor_list = NULL;

    if ( global_hash )
    {
        _xdg_glob_hash_free ( global_hash );
        global_hash = NULL;
    }
    if ( global_magic )
    {
        _xdg_mime_magic_free ( global_magic );
        global_magic = NULL;
    }

    if ( alias_list )
    {
        _xdg_mime_alias_list_free ( alias_list );
        alias_list = NULL;
    }

    if ( parent_list )
    {
        _xdg_mime_parent_list_free ( parent_list );
        parent_list = NULL;
    }
}

int
xdg_mime_get_max_buffer_extents ( void )
{
    if ( _caches )
        return _xdg_mime_cache_get_max_buffer_extents ();

    return _xdg_mime_magic_get_buffer_extents ( global_magic );
}

const char *
xdg_mime_unalias_mime_type ( const char *mime_type )
{
    const char * lookup;

    if ( _caches )
        return _xdg_mime_cache_unalias_mime_type ( mime_type );

    if ( ( lookup = _xdg_mime_alias_list_lookup ( alias_list, mime_type ) ) != NULL )
        return lookup;

    return mime_type;
}

int
xdg_mime_mime_type_equal ( const char *mime_a,
                           const char *mime_b )
{
    const char * unalias_a, *unalias_b;

    unalias_a = xdg_mime_unalias_mime_type ( mime_a );
    unalias_b = xdg_mime_unalias_mime_type ( mime_b );

    if ( strcmp ( unalias_a, unalias_b ) == 0 )
        return 1;

    return 0;
}

int
xdg_mime_media_type_equal ( const char *mime_a,
                            const char *mime_b )
{
    char * sep;

    sep = strchr ( mime_a, '/' );

    if ( sep && strncmp ( mime_a, mime_b, sep - mime_a + 1 ) == 0 )
        return 1;

    return 0;
}

#if 0
static int
xdg_mime_is_super_type ( const char *mime )
{
    int length;
    const char *type;

    length = strlen ( mime );
    type = &( mime[ length - 2 ] );

    if ( strcmp ( type, "/*" ) == 0 )
        return 1;

    return 0;
}
#endif

int
xdg_mime_mime_type_subclass ( const char *mime,
                              const char *base )
{
    const char * umime, *ubase;
    const char **parents;

    if ( _caches )
        return _xdg_mime_cache_mime_type_subclass ( mime, base );

    umime = xdg_mime_unalias_mime_type ( mime );
    ubase = xdg_mime_unalias_mime_type ( base );

    if ( strcmp ( umime, ubase ) == 0 )
        return 1;

#if 0
    /* Handle supertypes */
    if ( xdg_mime_is_super_type ( ubase ) &&
            xdg_mime_media_type_equal ( umime, ubase ) )
        return 1;
#endif

    /*  Handle special cases text/plain and application/octet-stream */
    if ( strcmp ( ubase, XDG_MIME_TYPE_PLAIN_TEXT ) == 0 &&
            strncmp ( umime, "text/", 5 ) == 0 )
        return 1;

    if ( strcmp ( ubase, XDG_MIME_TYPE_UNKNOWN ) == 0 )
        return 1;

    parents = _xdg_mime_parent_list_lookup ( parent_list, umime );
    for ( ; parents && *parents; parents++ )
    {
        if ( xdg_mime_mime_type_subclass ( *parents, ubase ) )
            return 1;
    }

    return 0;
}

char **
xdg_mime_list_mime_parents ( const char *mime )
{
    const char **parents;
    char **result;
    int i, n;

    if ( _caches )
        return _xdg_mime_cache_list_mime_parents ( mime );

    parents = xdg_mime_get_mime_parents ( mime );

    if ( !parents )
        return NULL;

    for ( i = 0; parents[ i ]; i++ )
        ;

    n = ( i + 1 ) * sizeof ( char * );
    result = ( char ** ) malloc ( n );
    memcpy ( result, parents, n );
    result[ i ] = NULL;

    return result;
}

const char **
xdg_mime_get_mime_parents ( const char *mime )
{
    const char * umime;
    umime = xdg_mime_unalias_mime_type ( mime );
    return _xdg_mime_parent_list_lookup ( parent_list, umime );
}

#if  0
void
xdg_mime_dump ( void )
{
    printf ( "*** ALIASES ***\n\n" );
    _xdg_mime_alias_list_dump ( alias_list );
    printf ( "\n*** PARENTS ***\n\n" );
    _xdg_mime_parent_list_dump ( parent_list );
}
#endif

/* Registers a function to be called every time the mime database reloads its files
 */
int
xdg_mime_register_reload_callback ( XdgMimeCallback callback,
                                    void *data,
                                    XdgMimeDestroy destroy )
{
    XdgCallbackList *list_el, *tail;
    static int callback_id = 1;

    /* Make a new list element */
    list_el = calloc ( 1, sizeof ( XdgCallbackList ) );
    list_el->callback_id = callback_id;
    list_el->callback = callback;
    list_el->data = data;
    list_el->destroy = destroy;

    /* Find tail of the list, added by Hong Jen Yee 2006.08.01 */
    if( !callback_list )
        callback_list = list_el;
    else
    {
        tail = callback_list;
        while( tail->next )
            tail = tail->next;
        list_el->prev = tail;
        tail->next = list_el;
    }
    callback_id ++;

    return callback_id - 1;
}

void
xdg_mime_remove_callback ( int callback_id )
{
    XdgCallbackList * list;

    for ( list = callback_list; list; list = list->next )
    {
        if ( list->callback_id == callback_id )
        {
            if ( list->next )
                list->next = list->prev;

            if ( list->prev )
                list->prev->next = list->next;
            else
                callback_list = list->next;

            /* invoke the destroy handler */
            if ( list->destroy )
            {
                ( list->destroy ) ( list->data );
            }
            free ( list );
            return ;
        }
    }
}