shortcut.c

Go to the documentation of this file.

/*
 * File Name: shortcut.c
 */

/*
 * This file is part of ctb.
 *
 * ctb 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 2 of the License, or
 * (at your option) any later version.
 *
 * ctb 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/>.
 */
 
/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

#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"


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

static const gchar  *FILE_SHORTCUT   = "[Desktop Entry]\n"
                                        "Version=1.0\n"
                                        "Type=Link\n"
                                        "URL=file:%s\n"
                                        "Name=%s\n";

static const gchar  *FOLDER_SHORTCUT = "[Desktop Entry]\n"
                                       "Version=1.0\n"
                                       "Type=Directory\n"
                                       "Path=%s\n"
                                       "Name=%s\n";


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------


//============================================================================
// Local Function Definitions
//============================================================================

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()
{
    shortcut_t  *thiz = g_new0( shortcut_t, 1 );
    g_assert(thiz);

    thiz->type = SHORTCUT_EMPTY;
    return thiz;
}


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

    return FALSE;
}


int create_shortcut_file ( const gchar   *target_dir,
                           const gchar   *target_file,
                           const gchar   *target_display,
                           const gchar   *shortcut_dir,
                                 GString *shortcut_file  )
{
    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;
}


int parse_shortcut_file ( const gchar      *directory,
                          const gchar      *filename,
                                shortcut_t **p_shortcut )
{
    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;
}


static int parse_file_url ( const gchar      *directory,
                            const gchar      *url,
                                  shortcut_t *shortcut )
{
    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;
}


static int parse_folder_path ( const gchar      *directory,
                               const gchar      *target_path,
                                     shortcut_t *shortcut)
{
    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;
}


void shortcut_free_impl ( shortcut_t* thiz )
{
    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);
}