shortcut.c File Reference

#include <glib.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "ctb_log.h"
#include "i18n.h"
#include "filetypes.h"
#include "shortcut.h"

Include dependency graph for shortcut.c:

Go to the source code of this file.

Functions
static int	parse_file_url (const gchar *directory, const gchar *url, shortcut_t *shortcut)
static int	parse_folder_path (const gchar *directory, const gchar *target_path, shortcut_t *shortcut)
static shortcut_t *	shortcut_new ()
static gboolean	path_has_invalid_characters (const gchar *path)
int	create_shortcut_file (const gchar *target_dir, const gchar *target_file, const gchar *target_display, const gchar *shortcut_dir, GString *shortcut_file)
	create a shortcut file
int	parse_shortcut_file (const gchar *directory, const gchar *filename, shortcut_t **p_shortcut)
	get details from shortcut file parses shortcut files recursively when applicable
void	shortcut_free_impl (shortcut_t *thiz)
Variables
static const char *	ILLEGAL_FILEPATH_CHARS = "*?\\:\"<>|"
static const gchar *	FILE_SHORTCUT
static const gchar *	FOLDER_SHORTCUT

---

Function Documentation

int create_shortcut_file	(	const gchar *	target_dir,
		const gchar *	target_file,
		const gchar *	target_display,
		const gchar *	shortcut_dir,
		GString *	shortcut_file
	)

create a shortcut file

---------------------------------------------------------------------------

Name : create_shortcut_file

Parameters:

[in]	target_dir	- folder in which the target is located specified as an absolute path
[in]	target_file	- file or folder to which the shortcut must point
[in]	target_display	- name displayed for target
[in]	shortcut_dir	- directory in which the shortcut file (xx.desktop) must be created specified as an absolute path
[out]	shortcut_file	- filename of the shortcut file created in shortcut_dir, or ignored when caller passes a NULL pointer here. Note: caller must allocate and release this GString.

Returns:

ER_OK - ok ER_NOT_FOUND - target not found ER_FORBIDDEN - directory or target directory not allowed or other error code

--------------------------------------------------------------------------

Definition at line 98 of file shortcut.c.

References ER_NOT_FOUND, ER_OK, ER_OPEN_ERROR, ER_WRITE_ERROR, FILE_EXT_SHORTCUT, FILE_EXT_SHORTCUT_TO_DIR, FILE_SHORTCUT, FOLDER_SHORTCUT, SHORTCUT_EMPTY, SHORTCUT_TO_FILE, and SHORTCUT_TO_FOLDER.

Referenced by create_shortcut_item().

{
    int             ret = ER_OK;     // return code

    g_assert( target_dir            && *target_dir   == '/'    );
    g_assert( target_file           && *target_file            );
    g_assert( target_display        && *target_display         );
    g_assert( shortcut_dir          && *shortcut_dir == '/'    );
    g_assert( shortcut_file == NULL || shortcut_file->len == 0 );
    g_assert( strlen(target_dir) < 256);
    g_assert( strlen(target_file) < 256);
    g_assert( strlen(shortcut_dir) < 256);

    // determine shortcut type
    gchar *target_path = g_strdup_printf("%s/%s", target_dir, target_file);

    shortcut_type_t shortcut_type = SHORTCUT_EMPTY;
    const gchar *shortcut_ext = "";
    if ( g_file_test(target_path, G_FILE_TEST_IS_REGULAR) )
    {
        shortcut_type = SHORTCUT_TO_FILE;
        shortcut_ext  = FILE_EXT_SHORTCUT;
    }
    else if ( g_file_test(target_path, G_FILE_TEST_IS_DIR) )
    {
        shortcut_type = SHORTCUT_TO_FOLDER;
        shortcut_ext  = FILE_EXT_SHORTCUT_TO_DIR;
    }
    else
    {
        ret = ER_NOT_FOUND;
        goto out;
    }

    // determine shortcut filename
    int seq = 0;
    char file[256];
    char shortcut_fullname[512];
    while (1) {
        seq++;
        sprintf(file, "%s_%03d.%s", target_file, seq, shortcut_ext);
        sprintf(shortcut_fullname, "%s/%s", shortcut_dir, file);
        if (!g_file_test(shortcut_fullname, G_FILE_TEST_EXISTS)) break;
    }

    // determine relative path shortcut -> target
    // skip identical pre-fix
    gchar *cp1 = target_path;
    gchar *cp2 = shortcut_fullname;
    while ( *cp1 != '\0'  &&  *cp1 == *cp2 )
    {
        cp1++;
        cp2++;
    }
    while ( *(cp1 - 1) != '/' )
    {
        cp1--;
        cp2--;
    }
    // count parent directories to traverse
    gboolean done = FALSE;
    GString *shortcut_target = g_string_new("");
    while ( !done )
    {
        while ( *cp2 == '/' )
        {
            cp2++;
        }
        cp2 = strchr(cp2, '/');
        if (cp2)
        {
            g_string_append(shortcut_target, "../");
        }
        else
        {
            done = TRUE;
        }
    }
    // append remaining part of shortcut target
    g_string_append(shortcut_target, cp1);

    FILE *fp = fopen(shortcut_fullname, "w");
    if (fp == NULL)
    {
        ret = ER_OPEN_ERROR;
        goto out2;
    }

    int rc = 0;
    // write shortcut details
    switch (shortcut_type)
    {
        case SHORTCUT_TO_FILE:
        {
            gchar* temp_uri = g_uri_escape_string(shortcut_target->str, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE);
            rc = fprintf( fp,
                          FILE_SHORTCUT,
                          temp_uri,                 // URL=
                          target_display        );  // Name=
            g_free(temp_uri   );
            break;
        }
        case SHORTCUT_TO_FOLDER:
            rc = fprintf( fp,
                          FOLDER_SHORTCUT,
                          shortcut_target->str,     // Path=
                          target_display        );  // Name=
            break;

        default:
            g_assert_not_reached();
    }
    if (rc <= 0)
    {
        ret = ER_WRITE_ERROR;
    }

    rc = fclose(fp);
    if (rc != 0)
    {
        ret = ER_WRITE_ERROR;
    }

    // set output parameters
    if (ret == ER_OK && shortcut_file)
    {
        g_string_assign(shortcut_file, file);
    }

out2:
    g_string_free(shortcut_target, TRUE);
out:
    g_free(target_path);
    return ret;
}

Here is the caller graph for this function:

static int parse_file_url	(	const gchar *	directory,
		const gchar *	url,
		shortcut_t *	shortcut
	)			[static]

Definition at line 469 of file shortcut.c.

References cp, shortcut_t::details, ER_INVALID_DATA, ER_NOT_FOUND, ER_OK, shortcut_t::file, LOGPRINTF, path, path_has_invalid_characters(), SHORTCUT_TO_FILE, and shortcut_t::type.

Referenced by parse_shortcut_file().

{
    int         ret = ER_OK;            // return code

    LOGPRINTF("entry: dir [%s] url [%s]", directory, url);
    g_assert(directory && *directory);
    g_assert(url       && *url      );
    g_assert(shortcut  && shortcut->type == SHORTCUT_TO_FILE);

    // strip scheme:
    char *cp = strchr(url, ':');
    char *url_path   = NULL;     // path component from url
    if (cp == NULL)
    {
        url_path = g_strdup(url);
    }
    else if ( g_str_has_prefix(url, "file:") )
    {
        url_path = g_strdup(cp + 1);
    }
    else
    {
        ret = ER_INVALID_DATA;
    }

    // strip //authority
    if (   url_path[0] == '/'
        && url_path[1] == '/' )
    {
        if ( url_path[2] == '/' )
        {
            // authority is empty: ok
            strcpy(url_path, url_path + 2);
        }
        else
        {
            // autohority filled in: not implemented
            ret = ER_INVALID_DATA;
        }
    }

    // strip ?query
    cp = strchr(url_path, '?');
    if (cp)
    {
        *cp = '\0';
    }

    // strip #fragment
    cp = strchr(url_path, '#');
    if (cp)
    {
        *cp = '\0';
    }

    // unescape %<hex><hex> strings, without failing on any character
    cp = g_uri_unescape_string(url_path, NULL);
    if (cp)
    {
        g_free(url_path);
        url_path = cp;
    }

    // check no illegal characters in path
    if ( path_has_invalid_characters(url_path) )
    {
        ret = ER_INVALID_DATA;
    }

    // detemine path on filesystem
    char *fs_path = NULL;     // path on filesystem
    if (ret == ER_OK)
    {
        if (url_path[0] == '/')
        {
            fs_path = url_path;
            url_path = NULL;
        }
        else
        {
            fs_path = g_strdup_printf("%s/%s", directory, url_path);
        }
    }

    // get real path
    char path[PATH_MAX];
    if (ret == ER_OK)
    {
        cp = realpath(fs_path, path);
        if (cp != path)
        {
            ret = ER_NOT_FOUND;
        }
    }

    // check target is a file
    if (ret == ER_OK)
    {
        gboolean ok = g_file_test(path, G_FILE_TEST_IS_REGULAR);
        if (!ok)
        {
            ret = ER_NOT_FOUND;
        }
    }

    // report our findings
    if (ret == ER_OK)
    {
        shortcut->details.file.filename = g_path_get_basename(path);
        shortcut->details.file.directory = g_path_get_dirname(path);
        LOGPRINTF("file [%s] dir [%s]", shortcut->details.file.filename, shortcut->details.file.directory);
    }

    g_free(fs_path);
    g_free(url_path);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int parse_folder_path	(	const gchar *	directory,
		const gchar *	target_path,
		shortcut_t *	shortcut
	)			[static]

Definition at line 590 of file shortcut.c.

References cp, shortcut_t::details, ER_INVALID_DATA, ER_OK, ERRORPRINTF, shortcut_t::folder, path, path_has_invalid_characters(), SHORTCUT_TO_FOLDER, and shortcut_t::type.

Referenced by parse_shortcut_file().

{
    g_assert(directory   && *directory  );
    g_assert(target_path && *target_path);
    g_assert(shortcut    && shortcut->type == SHORTCUT_TO_FOLDER);
    g_assert(shortcut->details.folder.directory == NULL);
    g_assert(shortcut->details.folder.filename  == NULL);

    // check no illegal characters in path
    if ( path_has_invalid_characters(target_path) )
    {
        ERRORPRINTF("invalid character in target_path [%s]", target_path);
        return ER_INVALID_DATA;
    }

    // determine path on filesystem
    char *fs_path = NULL;
    if (target_path[0] == '/')
    {
        fs_path  = g_strdup(target_path);
    }
    else
    {
        fs_path = g_strdup_printf("%s/%s", directory, target_path);
    }

    // get real path, if target present
    char path[PATH_MAX] = "";
    gchar *cp = realpath(fs_path, path);
    if (cp != path) {
        g_free(fs_path);
        return ER_INVALID_DATA;
    }

    gchar *dir  = g_path_get_dirname(path);
    gchar *file = g_path_get_basename(path);

    shortcut->details.folder.directory = dir;
    shortcut->details.folder.filename  = file;

    g_free(fs_path );
    return ER_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int parse_shortcut_file	(	const gchar *	directory,
		const gchar *	filename,
		shortcut_t **	p_shortcut
	)

get details from shortcut file parses shortcut files recursively when applicable

---------------------------------------------------------------------------

Name : parse_shortcut_file

Parameters:

[in]	directory	- directory in which the shortcut file (xx.desktop) is located
[in]	filename	- filename of the shortcut file
[out]	p_shortcut	- structure with details of the requested shortcut, caller must release this with shortcut_free()

Returns:

ER_OK - ok ER_NOT_FOUND - target location not found ER_INVALID_DATA - contents of shortcut file is corrupt ER_FORBIDDEN - target directory not allowed or other error code

--------------------------------------------------------------------------

Definition at line 239 of file shortcut.c.

References shortcut_t::application, shortcut_t::comment, cp, shortcut_t::details, ER_FAIL, ER_INVALID_DATA, ER_NOT_FOUND, ER_OK, ERRORPRINTF, shortcut_t::filepath, shortcut_t::folder, shortcut_t::keyfile, shortcut_t::name, parse_file_url(), parse_folder_path(), path, path_has_invalid_characters(), shortcut_free, shortcut_new(), SHORTCUT_TO_APPLICATION, SHORTCUT_TO_FILE, SHORTCUT_TO_FOLDER, SHORTCUT_TO_WEB_LOCATION, shortcut_t::type, and shortcut_t::web.

Referenced by activate_shortcut(), check_shortcut(), get_thumbnail(), and load_items_in_model().

{
    g_assert(directory  && *directory );
    g_assert(filename   && *filename  );
    g_assert(p_shortcut && *p_shortcut == NULL);

    GKeyFile *keyfile = g_key_file_new();
    shortcut_t *shortcut = shortcut_new();
    shortcut->keyfile = keyfile;
    gchar *filepath = g_strdup_printf("%s/%s", directory, filename);
    shortcut->filepath = filepath;

    int ret = ER_OK;
    if (!g_file_test(filepath, G_FILE_TEST_IS_REGULAR))
    {
        ret = ER_NOT_FOUND;
        goto out;
    }

    if (!g_key_file_load_from_file( keyfile,
                                    filepath,
                                    G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS,
                                    NULL))
    {
        ret = ER_INVALID_DATA;
        goto out;
    }

    // get name
    shortcut->name = g_key_file_get_locale_string( keyfile,
                                          G_KEY_FILE_DESKTOP_GROUP,
                                          G_KEY_FILE_DESKTOP_KEY_NAME,
                                          NULL,
                                          NULL );
    if (shortcut->name == NULL)
    {
        ret = ER_INVALID_DATA;
        goto out;
    }

    // get comments
    shortcut->comment = g_key_file_get_locale_string( keyfile,
                                  G_KEY_FILE_DESKTOP_GROUP,
                                  G_KEY_FILE_DESKTOP_KEY_COMMENT,
                                  NULL,
                                  NULL );

    // get version (optional)
    gchar* version = g_key_file_get_string( keyfile,
                                   G_KEY_FILE_DESKTOP_GROUP,
                                   G_KEY_FILE_DESKTOP_KEY_VERSION,
                                   NULL );
    if (version != NULL)
    {
        int compare = strcmp(version, "1.0");
        g_free(version);
        if (compare != 0) {
            ret = ER_INVALID_DATA;
            goto out;
        }
    }

    // get type
    gchar *type = g_key_file_get_string( keyfile,
                                   G_KEY_FILE_DESKTOP_GROUP,
                                   G_KEY_FILE_DESKTOP_KEY_TYPE,
                                   NULL );
    if (type == NULL)
    {
        // type not found: error
        ret = ER_INVALID_DATA;
        goto out;
    }

    // type found: store in shortcut
    if ( strcmp(type, G_KEY_FILE_DESKTOP_TYPE_LINK) == 0 )
    {
        shortcut->type = SHORTCUT_TO_FILE;
    }
    else if ( strcmp(type, G_KEY_FILE_DESKTOP_TYPE_DIRECTORY) == 0 )
    {
        shortcut->type = SHORTCUT_TO_FOLDER;
    }
    else if ( strcmp(type, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) == 0 )
    {
        shortcut->type = SHORTCUT_TO_APPLICATION;
    }
    else
    {
        g_free(type);
        ret = ER_INVALID_DATA;
        goto out;
    }
    g_free(type);

    // get type-dependent keys
    switch (shortcut->type)
    {
        case SHORTCUT_TO_FILE:
        {
            // get url
            gchar *url = g_key_file_get_string( keyfile,
                                           G_KEY_FILE_DESKTOP_GROUP,
                                           G_KEY_FILE_DESKTOP_KEY_URL,
                                           NULL );
            if (url == NULL)
            {
                ret = ER_INVALID_DATA;
                goto out;
            }

            // url found: convert to path, store in shortcut

            // get scheme from url
            // note: scheme might indicate url points to a web location
            if ( g_str_has_prefix(url, "http:") || g_str_has_prefix(url, "https:") )
            {
                // web location: remember details and leave
                shortcut->type = SHORTCUT_TO_WEB_LOCATION;
                shortcut->details.web.url = url;
                ret = ER_OK;
                break;  // exit switch
            }
            else if ( g_str_has_prefix(url, "file:") )
            {
                // local file location: get real path
                ret = parse_file_url( directory, url, shortcut );
            }
            else
            {
                // scheme not implemented
                ret = ER_INVALID_DATA;
                goto out;
            }

            // clean up
            g_free(url);
            break;
        }
        case SHORTCUT_TO_FOLDER:
        {
            // get path
            gchar *path = g_key_file_get_string( keyfile,
                                           G_KEY_FILE_DESKTOP_GROUP,
                                           G_KEY_FILE_DESKTOP_KEY_PATH,
                                           NULL );
            if (path == NULL)
            {
                ret = ER_INVALID_DATA;
                goto out;
            }

            // key found: check on invalid characters
            if ( path_has_invalid_characters(path) )
            {
                ret = ER_INVALID_DATA;
                goto out;
            }

            // path found: convert to realpath, store in shortcut
            ret = parse_folder_path( directory, path, shortcut );
            shortcut->details.folder.path = path;
            break;
        }
        // note: no nesting of shortcut to application
        case SHORTCUT_TO_APPLICATION:
        {
            // get exec
            gchar *executable = g_key_file_get_string( keyfile,
                                           G_KEY_FILE_DESKTOP_GROUP,
                                           G_KEY_FILE_DESKTOP_KEY_EXEC,
                                           NULL );
            if (executable == NULL)
            {
                ret = ER_INVALID_DATA;
                goto out;
            }

            // key found: store in shortcut
            if (strncmp(executable, "./",  2) == 0 || strncmp(executable, "../", 3) == 0)
            {
                // relative path: prepend shortcut directory
                // shell quote to preserve spaces in directory
                gchar *directory_quoted = g_shell_quote(directory);
                gchar *cp = g_strdup_printf("%s/%s", directory_quoted, executable);
                g_free(directory_quoted);
                g_free(executable);
                executable = cp;
            }
            shortcut->details.application.command_line = executable;

            // get path (optional)
            gchar* path = g_key_file_get_string( keyfile,
                                           G_KEY_FILE_DESKTOP_GROUP,
                                           G_KEY_FILE_DESKTOP_KEY_PATH,
                                           NULL );
            if (path != NULL)
            { 
                // key found: check on invalid characters
                if ( path_has_invalid_characters(path) )
                {
                    g_free(path);
                    ret = ER_INVALID_DATA;
                    goto out;
                }
                // path ok: store in shortcut
                shortcut->details.application.work_dir = path;
            }
            break;
        }
        default:
            ERRORPRINTF("unknown type %d", shortcut->type);
            ret = ER_FAIL;
            break;
    }

    if (ret == ER_OK)
    {
        *p_shortcut = shortcut;
        return ER_OK;
    }

out:
    shortcut_free(shortcut);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean path_has_invalid_characters

(

const gchar *

path

)

[static]

Definition at line 85 of file shortcut.c.

References cp, and ILLEGAL_FILEPATH_CHARS.

Referenced by parse_file_url(), parse_folder_path(), and parse_shortcut_file().

{
    const gchar *illegal;
    for ( illegal = ILLEGAL_FILEPATH_CHARS ; *illegal ; illegal++ )
    {
        gchar *cp = strchr(path, *illegal);
        if (cp) return TRUE;
    }

    return FALSE;
}

Here is the caller graph for this function:

void shortcut_free_impl

(

shortcut_t *

thiz

)

Definition at line 637 of file shortcut.c.

References shortcut_t::application, shortcut_t::comment, shortcut_t::details, ERRORPRINTF, shortcut_t::file, shortcut_t::filepath, shortcut_t::folder, shortcut_t::keyfile, shortcut_t::name, SHORTCUT_EMPTY, SHORTCUT_TO_APPLICATION, SHORTCUT_TO_FILE, SHORTCUT_TO_FOLDER, SHORTCUT_TO_WEB_LOCATION, shortcut_t::type, and shortcut_t::web.

{
    if (thiz == NULL) return;

    g_free(thiz->filepath);
    if (thiz->keyfile)
    {
        g_key_file_free(thiz->keyfile);
    }
    g_free(thiz->name);
    g_free(thiz->comment);
    switch (thiz->type)
    {
        case SHORTCUT_EMPTY:
            ; //ignore
            break;

        case SHORTCUT_TO_FILE:
            g_free(thiz->details.file.directory);
            g_free(thiz->details.file.filename );
            break;

        case SHORTCUT_TO_WEB_LOCATION:
            g_free(thiz->details.web.url);
            break;

        case SHORTCUT_TO_FOLDER:
            g_free(thiz->details.folder.path);
            g_free(thiz->details.folder.directory);
            g_free(thiz->details.folder.filename );
            break;

        case SHORTCUT_TO_APPLICATION:
            g_free(thiz->details.application.command_line);
            break;

        default:
            ERRORPRINTF("illegal shortcut type [%d]", thiz->type);
            ; //ignore
    }

    g_free(thiz);
}

static shortcut_t* shortcut_new

(

)

[static]

Definition at line 75 of file shortcut.c.

References SHORTCUT_EMPTY, and shortcut_t::type.

Referenced by parse_shortcut_file().

{
    shortcut_t  *thiz = g_new0( shortcut_t, 1 );
    g_assert(thiz);

    thiz->type = SHORTCUT_EMPTY;
    return thiz;
}

Here is the caller graph for this function:

---

Variable Documentation

const gchar* FILE_SHORTCUT [static]

Initial value:

 "[Desktop Entry]\n"
                                        "Version=1.0\n"
                                        "Type=Link\n"
                                        "URL=file:%s\n"
                                        "Name=%s\n"

Definition at line 45 of file shortcut.c.

Referenced by create_shortcut_file().

const gchar* FOLDER_SHORTCUT [static]

Initial value:

 "[Desktop Entry]\n"
                                       "Version=1.0\n"
                                       "Type=Directory\n"
                                       "Path=%s\n"
                                       "Name=%s\n"

Definition at line 51 of file shortcut.c.

Referenced by create_shortcut_file().

const char* ILLEGAL_FILEPATH_CHARS = "*?\\:\"<>|" [static]

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Definition at line 43 of file shortcut.c.

Referenced by path_has_invalid_characters().