#!/bin/sh
#---------------------------------------------
#   xdg-open
#
#   Utility script to open a URL in the registered default application.
#
#   Refer to the usage() function below for usage.
#
#   Copyright 2009-2010, Fathi Boudra <fabo@freedesktop.org>
#   Copyright 2009-2016, Rex Dieter <rdieter@fedoraproject.org>
#   Copyright 2006, Kevin Krammer <kevin.krammer@gmx.at>
#   Copyright 2006, Jeremy White <jwhite@codeweavers.com>
#
#   LICENSE:
#
#   Permission is hereby granted, free of charge, to any person obtaining a
#   copy of this software and associated documentation files (the "Software"),
#   to deal in the Software without restriction, including without limitation
#   the rights to use, copy, modify, merge, publish, distribute, sublicense,
#   and/or sell copies of the Software, and to permit persons to whom the
#   Software is furnished to do so, subject to the following conditions:
#
#   The above copyright notice and this permission notice shall be included
#   in all copies or substantial portions of the Software.
#
#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
#   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
#   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
#   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
#   OTHER DEALINGS IN THE SOFTWARE.
#
#---------------------------------------------

manualpage()
{
cat << '_MANUALPAGE'
Name

xdg-open - opens files and/or URLs in the user's preferred applications

Synopsis

xdg-open [ --nowait ] [ -- ] { file | URL ...}

xdg-open { --help | --manual | --version }

Description

xdg-open opens the given files and/or URLs in the user's preferred
applications.

xdg-open is for use inside a desktop session only. It is not recommended to use
xdg-open as root.

As xdg-open can not handle arguments that begin with a “-” it is recommended to
pass filepaths in one of the following ways:

  • Pass absolute paths, i.e. by using xdg-realpath as a preprocessor.

  • Prefix known relative filepaths with a “./”. For example using sed -E 's|^
    [^/]|./\0|'.

  • Pass a file URL.

Options

--

    Indicate that whatever follows is a filename or URL, not an option.

    This option is new and incompatible with older releases! Consider escaping
    or using realpath instead.

    Internally this will the prefix escaping strategy for filenames that begin
    with hyphens outlined above.

--nowait
    Do not wait for the opener to exit after launching the last URL.
--help
    Show command synopsis.
--manual
    Show this manual page.
--version
    Show the xdg-utils version information.

Exit Codes

An exit code of 0 indicates success while a non-zero exit code indicates
failure. The following failure codes can be returned:

1
    Error in command line syntax.
2
    One of the files passed on the command line did not exist.
3
    A required tool could not be found.
4
    At least one file or URL could not be opened.

In case of success the process launched from the .desktop file will not be
forked off and therefore may result in xdg-open running for a very long time.
This behaviour intentionally differs from most desktop specific openers to
allow terminal based applications to run using the same terminal xdg-open was
called from.

Environment

xdg-open honors the following environment variables:

BROWSER

    May contain a command that is used to open a filepath or URL when no other
    appropriate opener was found. The Path or URL will be appended as the last
    argument.

    No parsing beyond splitting arguments on space characters should be
    assumed. Quoting is not supported. Be careful with ':' and '%' characters.

    The following two features are supported in xdg-open only, but not by other
    applications that make use of the BROWSER variable. Using them is no longer
    recommended.

    This environment variable may contain a colon separated list of commands if
    one command fails the command after it will be tried.

    When using %s as a placeholder the first instance of it will be replaced
    with the filepath or URL to be opened instead of appending it as the last
    argument.

Reporting Issues

Please keep in mind xdg-open inherits most of the flaws of its configuration
and the underlying opener.

In case the command xdg-mime query default "$(xdg-mime query filetype path/to/
troublesome_file)" names the program responsible for any unexpected behaviour
you can fix that by setting a different handler. (If the program is broken let
the developers know)

Also see the security note on xdg-mime(1) for the default subcommand.

If a flaw is reproducible using the desktop specific opener (and isn't a
configuration issue): Please report to whoever is responsible for that first
(reporting to xdg-utils is better than not reporting at all, but since the
xdg-utils are maintained in very little spare time a fix will take much longer)

In case an issue specific to xdg-open please report it to https://
gitlab.freedesktop.org/xdg/xdg-utils/-/issues .

See Also

xdg-mime(1), xdg-settings(1), xdg-realpath(1), xdg-utils-common(7), MIME
applications associations specification

Examples

xdg-open 'http://www.freedesktop.org/'

Opens the freedesktop.org website in the user's default browser.

xdg-open /tmp/foobar.png

Opens the PNG image file /tmp/foobar.png in the user's default image viewing
application.

_MANUALPAGE
}

usage()
{
cat << '_USAGE'
xdg-open - opens files and/or URLs in the user's preferred applications

Synopsis

xdg-open [ --nowait ] [ -- ] { file | URL ...}

xdg-open { --help | --manual | --version }

_USAGE
}

XDG_UTILS_ENABLE_DOUBLE_HYPEN="y"

#@xdg-utils-common@
#----------------------------------------------------------------------------
#   Common utility functions included in all XDG wrapper scripts
#----------------------------------------------------------------------------

#shellcheck shell=sh

# (level, echo_args ...)
DEBUG()
{
  [ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && return 0;
  [ "${XDG_UTILS_DEBUG_LEVEL}" -lt "$1" ] && return 0;
  shift
  echo "$@" >&2
}

# This handles backslashes but not quote marks.
# 
# (text)
# shellcheck disable=SC2317 # Not using this function is okay
first_word()
{
    # shellcheck disable=SC2162 # No -r is intended here
    read first rest
    echo "$first"
}

#-------------------------------------------------------------
# map a binary to a .desktop file
# 
# (command_or_path_to_binary)
# shellcheck disable=SC2317 # Not using this function is okay
binary_to_desktop_file()
{
    if [ -z "$1" ] ; then
        DEBUG 2 "binary_to_desktop_file argument is empty"
        return
    fi
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    binary="$(command -v "$1")"
    binary="$(xdg_realpath "$binary")"
    base="$(basename "$binary")"
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" ] || continue
        [ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
        for file in "$dir"/applications/*.desktop "$dir"/applications/*/*.desktop "$dir"/applnk/*.desktop "$dir"/applnk/*/*.desktop; do
            [ -r "$file" ] || continue
            # Check to make sure it's worth the processing.
            grep -q "^Exec.*$base" "$file" || continue
            # Make sure it's a visible desktop file (e.g. not "preferred-web-browser.desktop").
            grep -Eq "^(NoDisplay|Hidden)=true" "$file" && continue
            command="$(grep -E "^Exec(\[[^]=]*])?=" "$file" | cut -d= -f 2- | first_word)"
            command="$(command -v "$command")"
            if [ x"$(xdg_realpath "$command")" = x"$binary" ]; then
                # Fix any double slashes that got added path composition
                echo "$file" | tr -s /
                return
            fi
        done
    done
}

#-------------------------------------------------------------
# map a .desktop file name to its Exec binary
# Returns the realpath resolved path to the binary or noting.

# (desktop_file_name)
# shellcheck disable=SC2317 # Not using this function is okay
desktop_file_to_binary()
{
    DEBUG 1 "desktop_file_to_binary '$1'"
    if [ -z "$1" ] ; then
        DEBUG 2 "desktop_file_to_binary argument is empty"
        return
    fi
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    desktop="$(basename "$1")"
    IFS=:
    for dir in $search; do
        DEBUG 2 "Searching in '$dir/{applications,applnk}'"
        unset IFS
        [ -n "$dir" ] && [ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
        # Check if desktop file contains -
        if [ "${desktop#*-}" != "$desktop" ]; then
            vendor="${desktop%-*}"
            app="${desktop#*-}"
            if [ -r "$dir/applications/$vendor/$app" ]; then
                file_path="$dir/applications/$vendor/$app"
            elif [ -r "$dir/applnk/$vendor/$app" ]; then
                file_path="$dir/applnk/$vendor/$app"
            fi
        fi
        if test -z "$file_path" ; then
            for indir in "$dir"/applications/ "$dir"/applications/*/ "$dir"/applnk/ "$dir"/applnk/*/; do
		        DEBUG 4 "Does file exist? '$indir/$desktop'"
                file="$indir/$desktop"
                if [ -r "$file" ]; then
                    file_path="$file"
                    break
                fi
            done
        fi
        if [ -r "$file_path" ]; then
	        DEBUG 2 "Checking desktop file '$file_path'"
            # Get the command name from the correct Exec
            # Note: Ignoring quoting and escape sequences here, see #253
            binary="$(awk -F '=' '
            	/^\[/{ in_entry=0 }
            	$0 == "[Desktop Entry]"{ in_entry=1 }
            	in_entry && /^Exec\s*=/ {
					sub(/^\s+/,"",$2);
					match($2,/^[^ ]+/);
					print substr($2,RSTART,RLENGTH)
				}' \
            	< "$file_path" )"
            if [ -z "$binary" ] ; then
                DEBUG 2 "No or empty Exec key in .desktop file. Search failed."
                return
            fi
            DEBUG 2 "Found command: $binary"
            binary="$(xdg_which "$binary")"
            DEBUG 2 "Resolved to command to file: '$binary'"
            [ -z "$binary" ] || xdg_realpath "$binary"
            return
        fi
    done
}

#-------------------------------------------------------------
# Exit script on successfully completing the desired operation

# (message (optional))
# shellcheck disable=SC2120 # It is okay to call this without arguments
# shellcheck disable=SC2317 # Not using this function is okay
exit_success()
{
    if [ $# -gt 0 ]; then
        echo "$*"
        echo
    fi

    exit 0
}


#-----------------------------------------
# Exit script on malformed arguments, not enough arguments
# or missing required option.
# prints usage information

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_syntax()
{
    if [ $# -gt 0 ]; then
        echo "xdg-open: $*" >&2
        echo "Try 'xdg-open --help' for more information." >&2
    else
        usage
        echo "Use 'man xdg-open' or 'xdg-open --manual' for additional info."
    fi

    exit 1
}

#-------------------------------------------------------------
# Exit script on missing file specified on command line

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_file_missing()
{
    if [ $# -gt 0 ]; then
        echo "xdg-open: $*" >&2
    fi

    exit 2
}

#-------------------------------------------------------------
# Exit script on failure to locate necessary tool applications

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_operation_impossible()
{
    if [ $# -gt 0 ]; then
        echo "xdg-open: $*" >&2
    fi

    exit 3
}

#-------------------------------------------------------------
# Exit script on failure returned by a tool application

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_operation_failed()
{
    if [ $# -gt 0 ]; then
        echo "xdg-open: $*" >&2
    fi

    exit 4
}

#------------------------------------------------------------
# Exit script on insufficient permission to read a specified file

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_file_permission_read()
{
    if [ $# -gt 0 ]; then
        echo "xdg-open: $*" >&2
    fi

    exit 5
}

#------------------------------------------------------------
# Exit script on insufficient permission to write a specified file

# (message (optional))
# shellcheck disable=SC2317 # Not using this function is okay
exit_failure_file_permission_write()
{
    if [ $# -gt 0 ]; then
        echo "xdg-open: $*" >&2
    fi

    exit 6
}

# (path)
# shellcheck disable=SC2317 # Not using this function is okay
check_input_file()
{
    if [ ! -e "$1" ]; then
        exit_failure_file_missing "file '$1' does not exist"
    fi
    if [ ! -r "$1" ]; then
        exit_failure_file_permission_read "no permission to read file '$1'"
    fi
}

# (label_for_error_message, path_to_check)
# shellcheck disable=SC2317 # Not using this function is okay
check_vendor_prefix()
{
    file_label="$2"
    [ -n "$file_label" ] || file_label="filename"
    file="$(basename "$1")"
    case "$file" in
       [[:alpha:]]*-*)
         return
         ;;
    esac

    echo "xdg-open: $file_label '$file' does not have a proper vendor prefix" >&2
    echo 'A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated' >&2
    echo 'with a dash ("-"). An example '"$file_label"' is '"'example-$file'" >&2
    echo "Use --novendor to override or 'xdg-open --manual' for additional info." >&2
    exit 1
}

# (path)
# shellcheck disable=SC2317 # Not using this function is okay
check_output_file()
{
    # if the file exists, check if it is writeable
    # if it does not exists, check if we are allowed to write on the directory
    if [ -e "$1" ]; then
        if [ ! -w "$1" ]; then
            exit_failure_file_permission_write "no permission to write to file '$1'"
        fi
    else
        DIR="$(dirname "$1")"
        if [ ! -w "$DIR" ] || [ ! -x "$DIR" ]; then
            exit_failure_file_permission_write "no permission to create file '$1'"
        fi
    fi
}

#----------------------------------------
# Checks for shared commands, e.g. --help

# (args ...)
check_common_commands()
{
    while [ $# -gt 0 ] ; do
        parm="$1"
        shift

        case "$parm" in
            --help)
            usage
            echo "Use 'man xdg-open' or 'xdg-open --manual' for additional info."
            exit_success
            ;;

            --manual)
            manualpage
            exit_success
            ;;

            --version)
            echo "xdg-open 1.2.99"
            exit_success
            ;;

            --)
	        [ -z "$XDG_UTILS_ENABLE_DOUBLE_HYPEN" ] || break
	        ;;
        esac
    done
}

check_common_commands "$@"

[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && unset XDG_UTILS_DEBUG_LEVEL;
# shellcheck disable=SC2034
if [ "${XDG_UTILS_DEBUG_LEVEL-0}" -lt 1 ]; then
    # Be silent
    xdg_redirect_output=" > /dev/null 2> /dev/null"
else
    # All output to stderr
    xdg_redirect_output=" >&2"
fi

#--------------------------------------
# Checks for known desktop environments
# set variable DE to the desktop environments name, lowercase
# Don't forget to update the manpage!
#
# ()
detectDE()
{
    # see https://bugs.freedesktop.org/show_bug.cgi?id=34164
    unset GREP_OPTIONS

    # Tool specific desktop override
    xdg_util="$(basename -- "$0" | sed 's/^xdg-//' | tr '[:lower:]' '[:upper:]')"
    # printenv isn't posix, but implemented by almost all coreutils packages
    DE="$(printenv -- "XDG_UTILS_${xdg_util}_OVERRIDE_DE")"
    unset xdg_util
    [ -z "$DE" ] || return

    # General desktop override
    if [ -n "${XDG_UTILS_OVERRIDE_DE}" ]; then
        DE="${XDG_UTILS_OVERRIDE_DE}"
        return
    fi

    # Check for toolbx first; as this runs "inside" an existing
    # environment.
    if [ -f /run/.toolboxenv ]; then
       DE="toolbx"
       return
    fi

    IFS=:
    for desktop in $XDG_CURRENT_DESKTOP ; do
      unset IFS
      case "$desktop" in
         # only recently added to menu-spec, pre-spec X- still in use
         Cinnamon|X-Cinnamon)
           DE=cinnamon;
           ;;
         ENLIGHTENMENT)
           DE=enlightenment;
           ;;
         # GNOME, GNOME-Classic:GNOME, or GNOME-Flashback:GNOME
         GNOME)
           DE=gnome;
           ;;
         KDE)
           DE=kde;
           ;;
         DEEPIN|Deepin|deepin|DDE)
           DE=deepin;
           ;;
         LXDE)
           DE=lxde;
           ;;
         LXQt)
           DE=lxqt;
           ;;
         MATE)
           DE=mate;
           ;;
         XFCE)
           DE=xfce
           ;;
         X-Generic)
           DE=generic
           ;;
      esac
      [ -n "$DE" ] && break
    done

    # shellcheck disable=SC2153
    if [ -z "$DE" ]; then
      # classic fallbacks
      if [ -n "$KDE_FULL_SESSION" ]; then DE=kde;
      elif [ -n "$GNOME_DESKTOP_SESSION_ID" ]; then DE=gnome;
      elif [ -n "$MATE_DESKTOP_SESSION_ID" ]; then DE=mate;
      elif dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.SessionManager > /dev/null 2>&1 ; then DE=gnome;
      elif echo "$DESKTOP" | grep -q '^Enlightenment'; then DE=enlightenment;
      elif [ -n "$LXQT_SESSION_CONFIG" ]; then DE=lxqt;
      fi
    fi

    if [ -z "$DE" ]; then
      # fallback to checking $DESKTOP_SESSION
      case "$DESKTOP_SESSION" in
         gnome)
           DE=gnome;
           ;;
         LXDE|Lubuntu)
           DE=lxde;
           ;;
         MATE)
           DE=mate;
           ;;
         xfce|xfce4|'Xfce Session')
           DE=xfce;
           ;;
      esac
    fi

    if [ -z "$DE" ]; then
      # fallback to uname output for other platforms
      case "$(uname 2>/dev/null)" in
        CYGWIN*)
          DE=cygwin;
          ;;
        Darwin)
          DE=darwin;
          ;;
        Linux)
          grep -q microsoft /proc/version > /dev/null 2>&1 && \
          command -v explorer.exe > /dev/null 2>&1 && \
          DE=wsl;
          ;;
      esac
    fi

    if [ x"$DE" = x"gnome" ]; then
      # gnome-default-applications-properties is only available in GNOME 2.x
      # but not in GNOME 3.x
      command -v gnome-default-applications-properties > /dev/null || DE="gnome3"
    fi

    if [ -f "/.flatpak-info" ]; then
      DE="flatpak"
    fi
}

#----------------------------------------------------------------------------
# kfmclient exec/openURL can give bogus exit value in KDE <= 3.5.4
# It also always returns 1 in KDE 3.4 and earlier
# Simply return 0 in such case
# 
# (exit_code)
# shellcheck disable=SC2317 # Not using this function is okay
kfmclient_fix_exit_code()
{
    version="$(LC_ALL=C.UTF-8 kde-config --version 2>/dev/null | grep '^KDE')"
    major="$(echo "$version" | sed 's/KDE.*: \([0-9]\).*/\1/')"
    minor="$(echo "$version" | sed 's/KDE.*: [0-9]*\.\([0-9]\).*/\1/')"
    release="$(echo "$version" | sed 's/KDE.*: [0-9]*\.[0-9]*\.\([0-9]\).*/\1/')"
    test "$major" -gt 3 && return "$1"
    test "$minor" -gt 5 && return "$1"
    test "$release" -gt 4 && return "$1"
    return 0
}

#----------------------------------------------------------------------------
# Returns true if there is a graphical display attached.
#
# ()
# shellcheck disable=SC2317 # Not using this function is okay
has_display()
{
    if [ -n "$DISPLAY" ] || [ -n "$WAYLAND_DISPLAY" ]; then
        return 0
    else
        return 1
    fi
}

#----------------------------------------------------------------------------
# Prefixes a path with a "./" if it starts with a "-".
# This is useful for programs to not confuse paths with options.
#
# ()
# shellcheck disable=SC2317 # Not using this function is okay
unoption_path()
{
	case "$1" in
		-*)
			printf "./%s" "$1" ;;
		*)
			printf "%s" "$1" ;;
	esac
}

#----------------------------------------------------------------------------
# Performs a symlink and relative path resolving for a single argument.
# This will always fail if the given file does not exist!
#
# (path)
# shellcheck disable=SC2317 # Not using this function is okay
xdg_realpath()
{
	# allow caching and external configuration
	if [ -z "$XDG_UTILS_REALPATH_BACKEND" ] ; then
		if command -v realpath >/dev/null 2>/dev/null ; then
			lines="$(realpath -- / 2>&1)"
			if [ $? = 0 ] && [ "$lines" = "/" ] ; then
				XDG_UTILS_REALPATH_BACKEND="realpath"
			else
				# The realpath took the -- literally, probably the busybox implementation
				XDG_UTILS_REALPATH_BACKEND="busybox-realpath"
			fi
			unset lines
		elif command -v readlink >/dev/null 2>/dev/null ; then
			XDG_UTILS_REALPATH_BACKEND="readlink"
		else
			exit_failure_operation_failed "No usable realpath backend found. Have a realpath binary or a readlink -f that canonicalizes paths."
		fi
	fi
	# Always fail if the file doesn't exist (busybox realpath does that for example)
	[ -e "$1" ] || return 1
	case "$XDG_UTILS_REALPATH_BACKEND" in
		realpath)
			realpath -- "$1"
			;;
		busybox-realpath)
			# busybox style realpath implementations have options too
			realpath "$(unoption_path "$1")"
			;;
		readlink)
			readlink -f "$(unoption_path "$1")"
			;;
		*)
			exit_failure_operation_impossible "Realpath backend '$XDG_UTILS_REALPATH_BACKEND' not recognized."
			;;
	esac
}

#----------------------------------------------------------------------------
# The `which` command but as a shell implementation.
# Returns either the path of the resolved binary or nothing
# because command -v does not always return the path of a command
# (builtins, aliases, functions, etc.)
#
# (command)
# shellcheck disable=SC2317 # Not using this function is okay
xdg_which()
{
	case "$1" in
		'') return 1 ;;
		*/*)
			# We got a path containing slashes, test if it is executable
			# and return its absolute path with symlinks resolved.
			if [ -x "$1" ] ; then
				xdg_realpath "$1"
				return 0
			fi
			return 1
			;;
	esac
	# search PATH for command
	old_ifs="$IFS"
	IFS=:
	for p in $PATH ; do
		IFS="$old_ifs"
		if [ -x "$p/$1" ] ; then
			printf "%s\n" "$p/$1"
			return
		fi
	done
	return 1
}

#----------------------------------------------------------------------------
# Helper function that returns the value for `$XDG_CONFIG_HOME`,
# independent of it being explicitly set or simply a fallback.
#
# ()
# shellcheck disable=SC2317 # Not using this function is okay
get_xdg_config_home()
{
	# Only use XDG_CONFIG_HOME if it is an absolute path
	# shellcheck disable=SC2153 # not misspelled
	case "$XDG_CONFIG_HOME" in
		/*) printf "%s\n" "$XDG_CONFIG_HOME" ;;
		*) printf "%s\n" "$HOME/.config" ;;
	esac
}

# (string_that_may_be_an_url)
has_url_scheme()
{
	echo "$1" | LC_ALL=C grep -Eq '^[[:alpha:]][[:alpha:][:digit:]+\.\-]*:'
}

# Returns true if argument is a file:// URL or path
# (url_or_path)
is_file_url_or_path()
{
    if echo "$1" | grep -q '^file://' || ! has_url_scheme "$1" ; then
        return 0
    else
        return 1
    fi
}

# ()
get_hostname() {
    if [ -z "$HOSTNAME" ]; then
        if command -v hostname > /dev/null; then
            HOSTNAME=$(hostname)
        else
            HOSTNAME=$(uname -n)
        fi
    fi
}

# If argument is a file URL, convert it to a (percent-decoded) path.
# If not, leave it as it is.
# (file_url)
file_url_to_path()
{
    local file="$1"
    get_hostname
    if echo "$file" | grep -q '^file://'; then
        file=${file#file://localhost}
        file=${file#file://"$HOSTNAME"}
        file=${file#file://}
        if ! echo "$file" | grep -q '^/'; then
            echo "$file"
            return
        fi
        file=${file%%#*}
        file=${file%%\?*}
        local printf=printf
        if [ -x /usr/bin/printf ]; then
            printf=/usr/bin/printf
        fi
        file=$($printf "$(echo "$file" | sed -e 's@%\([a-f0-9A-F]\{2\}\)@\\x\1@g')")
    fi
    echo "$file"
}

# (url_or_path)
open_cygwin()
{
    cygstart "$1"

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_darwin()
{
    open "$1"

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_kde()
{
    if [ -n "${KDE_SESSION_VERSION}" ]; then
      case "${KDE_SESSION_VERSION}" in
        4)
          kde-open "$1"
        ;;
        5)
          "kde-open${KDE_SESSION_VERSION}" "$1"
        ;;
        6)
          kde-open "$1"
        ;;
        *)
	      DEBUG 0 "Detected an unknown KDE version using the KDE_SESSION_VERSION environment variable."
	      DEBUG 1 "If you are on something newer than Plasma 6 you are likely running an outdated version of the xdg-utils, please check for updates."
	      DEBUG 0 "Falling back to the generic opener."
	      open_generic "$1"
        ;;
      esac
    else
        kfmclient exec "$1"
        kfmclient_fix_exit_code $?
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_deepin()
{
    if dde-open -version >/dev/null 2>&1; then
        dde-open "$1"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_gnome3()
{
    if gio help open 2>/dev/null 1>&2; then
        gio open "$1"
    elif gvfs-open --help 2>/dev/null 1>&2; then
        gvfs-open "$1"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_gnome()
{
    if gio help open 2>/dev/null 1>&2; then
        gio open "$1"
    elif gvfs-open --help 2>/dev/null 1>&2; then
        gvfs-open "$1"
    elif gnome-open --help 2>/dev/null 1>&2; then
        gnome-open "$1"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_mate()
{
    if gio help open 2>/dev/null 1>&2; then
        gio open "$1"
    elif gvfs-open --help 2>/dev/null 1>&2; then
        gvfs-open "$1"
    elif mate-open --help 2>/dev/null 1>&2; then
        mate-open "$1"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_xfce()
{
    if xfce-open --help 2>/dev/null 1>&2; then
        xfce-open "$1"
    elif exo-open --help 2>/dev/null 1>&2; then
        exo-open "$1"
    elif gio help open 2>/dev/null 1>&2; then
        gio open "$1"
    elif gvfs-open --help 2>/dev/null 1>&2; then
        gvfs-open "$1"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_enlightenment()
{
    if enlightenment_open --help 2>/dev/null 1>&2; then
        enlightenment_open "$1"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_gdbus()
{
    if is_file_url_or_path "$1"; then
        local file
        file="$(file_url_to_path "$1")"

        check_input_file "$file"

        gdbus call --session \
            --dest org.freedesktop.portal.Desktop \
            --object-path /org/freedesktop/portal/desktop \
            --method org.freedesktop.portal.OpenURI.OpenFile \
            --timeout 5 \
            "" "3" {} 3< "$file"
    else
        # $1 contains an URI

        gdbus call --session \
            --dest org.freedesktop.portal.Desktop \
            --object-path /org/freedesktop/portal/desktop \
            --method org.freedesktop.portal.OpenURI.OpenURI \
            --timeout 5 \
            "" "$1" {}
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

#-----------------------------------------
# Recursively search .desktop file

awk_script_open_with_desktop_file="$(cat << 'AWKEOF'
BEGIN {

	debug_level = ENVIRON["XDG_UTILS_DEBUG_LEVEL"]

	if (uri_arg) {
		split(uri_arg, split_uri_arg, " ")
	}

	has_uri = 0;
	filec = 0;
	for (i=1; split_uri_arg[i]; i++) {
		has_uri = 1;
		uri = split_uri_arg[i]
		uris[i-1] = uri;
		debug(2, "URI: " uri)
		if (file_arg != "") {
			file = decode_local_file_uri(uri)
			if (file) {
				debug(2, "File: " file)
				files[filec] = file;
				filec = filec + 1;
			}
		}
	}

	if (file_arg != "") {
		debug(2, "File: " file_arg)
		files[filec] = file_arg;
		filec = filec + 1;
		if (!has_uri) {
			debug(2, "URI (falling back to file path): " file_arg)
			uris[0] = file_arg
		}
	}
	
	in_main_section = 0;

	exec_value = 0;
	icon_value = 0;
	name_value = 0;
}

/^\[/ {
	in_main_section = 0;
}

$0 == "[Desktop Entry]" {
	in_main_section = 1
}

function unescape_value(escaped) {
	value = ""
	for (i=1; i<=length(escaped); i++) {
		char = substr(escaped, i, 1)
		if (char == "\\") {
			i = i+1
			next_char = substr(escaped,i,1);
			if (next_char == "s") {
				value = value " ";
			} else if (next_char == "n") {
				value = value "\n";
			} else if (next_char == "t") {
				value = value "\t";
			} else if (next_char == "r") {
				value = value "\r";
			} else if (next_char == "\\") {
				value = value "\\";
			}
		} else {
			value = value char
		}
	}
	return value;
}

function split_exec_value(value, out_args) {
	argc = 0;
	in_quote = 0;
	current_arg = "";
	next_is_literal = 0;
	for (i=1; i<=length(value); i++) {
		char = substr(value,i,1)
		if (next_is_literal) {
			next_is_literal = 0;
			current_arg = current_arg char
			continue
		}
		if (in_quote) {
			if (char == "\"") {
				in_quote = 0;
				out_args[argc] = current_arg;
				argc = argc + 1;
				current_arg = "";
			} else if (char == "\\") {
				next_is_literal = 1;
			} else {
				current_arg = current_arg char
			}
		} else {
			if (current_arg == "" && char == "\"") {
				in_quote = 1;
			} else if (char != " ") {
				current_arg = current_arg char
			} else if (current_arg != "") {
				out_args[argc] = current_arg;
				argc = argc + 1;
				current_arg = "";
			}
		}
	}
	if (current_arg != "") {
		out_args[argc] = current_arg;
	}
}

function hex_value(char) {
	value = char - "0";
	if (value >= 0 && value < 10) {
		return value;
	}
	value = char - "a";
	if (value >= 10 && value < 16) {
		return value;
	}
	value = char - "A";
	if (value >= 10 && value < 16) {
		return value;
	}
	return 0;
}

function uri_decode(text) {
	output = ""
	for (i=1; i<=length(text); i++) {
		char = substr(text, i, 1);
		if (char != "%") {
			output = output char;
			continue
		}
		char_a = substr(text, i+1, 1);
		char_b = substr(text, i+2, 1);
		i = i+2;
		numeric = hex_value(char_a)*16+hex_value(char_b);
		if (numeric != 0 && numeric != 47) {
			output = output sprintf("%c", numeric)
		}
	}
	return output;
}

function decode_local_file_uri(uri) {
	if (!match(uri, /^file:\/\//)) {
		return 0;
	}
	host = ""
	path = 0
	slash_count = 0
	host_start = 0
	host_end = 0
	path_start = 0
	for (i=1; i<=length(uri); i++) {
		char = substr(text, i, 1);
		if (char == "/") {
			slash_count++;
			if (slash_count == 2) {
				host_start = i;
			}
			if (slash_count == 3) {
				path_start = i;
			}
			continue
		} else if (host_start && char == ":") {
			host_end = i;
		} else if (char == "?" || char == "#") {
			if (path_start) {
				path = substr(uri, path_start, i - path_start)
			}
			# ignore that we wouldn't fully parse the hostname in this case,
			# if the hostname isn't finished here it'll fail anyway.
			break
		}
		if (host_start && host_end) {
			host = substr(uri, host_start, host_end - host_start);
		}
	}
	# Hostname must either be empty, "localhost" or match local hostname
	if (host != "" && host != "localhost" && host != hostname) {
		return 0;
	}
	if (path) {
		return uri_decode(path)
	}
	return 0;
}

function debug(level, text) {
	if (!debug_level) {
		return;
	}
	if (level <= debug_level) {
		print "DEBUG: " text >> "/dev/stderr";
	}
}

function error(text) {
	printf("err\0");
	print "xdg-open ERROR: " text >> "/dev/stderr";
	exit 4
}

in_main_section && match($0, /^[^#=\[]+\[?[^=\]]*\]?=/) {
	index_of_eq = index($0, "=");
	index_of_bracket_open = index($0, "[");
	if (index_of_bracket_open && index_of_bracket_open < index_of_eq) {
		key = substr($0, 1, index_of_bracket_open-1)
		local = substr($0, index_of_bracket_open+1, index_of_eq-index_of_bracket_open-2);
	} else {
		key = substr($0, 1, index_of_eq-1);
		local = "";
	}
	value = substr($0, index_of_eq+1);
	debug(4, "Key: " key " Local: " local " Value: " value);
	if (key == "Exec") {
		exec_value = unescape_value(value);
	} else if (key == "Icon") {
		icon_value = unescape_value(value);
	} else if (key == "Name") {
		# TODO: handle actual localization
		if (local == "") {
			name_value = unescape_value(value)
		}
	}
}

END {
	if (!exec_value) {
		print "xdg-open: No Exec= line found in main section of desktop file!" >> "/dev/stderr";
		exit 1;
	}
	debug(2, "Unescaped: " exec_value)
	split_exec_value(exec_value, args)
	# Field code expansion
	expanded_args[0] = "";
	eargc = 0;
	found_file_field_codes = 0;
	for (i=0; args[i]; i++) {
		arg = args[i];
		debug(2, "Running field code expansion on arg: " arg);
		if (arg == "%F") {
			for (j=0; j<length(files); j++) {
				expanded_args[eargc] = files[j];
				eargc = eargc + 1;
			}
			found_file_field_codes++;
			continue
		} else if (arg == "%U") {
			for (j=0; j<length(uris); j++) {
				expanded_args[eargc] = uris[j];
				eargc = eargc + 1;
			}
			found_file_field_codes++;
			continue
		} else if (arg == "%i") {
			if (icon_value) {
				expanded_args[eargc] = "--icon"
				expanded_args[eargc] = icon_value
				eargc = eargc + 1;
			}
			continue
		}
		debug(2, "Trying to find in-text field code ...");
		expanded_arg = ""
		for (j=1; j<=length(arg); j++) {
			char = substr(arg,j,1);
			if (char != "%") {
				expanded_arg = expanded_arg char
				continue
			}
			j = j+1;
			char = substr(arg,j,1);
			debug(2, "Found field code expansion: %" char);
			if (char == "%") {
				expanded_arg = expanded_arg "%"
			} else if (char == "f") {
				# Take just the first arg for the prototype
				expanded_arg = expanded_arg files[0];
				found_file_field_codes++;
			} else if (char == "u") {
				# Take just the first arg for the prototype
				expanded_arg = expanded_arg uris[0];
				found_file_field_codes++;
			} else if (char == "c") {
				if (name_value) {
					expanded_arg = expanded_arg name_value
				}
			} else if (char == "k") {
				# Location of desktop file either as URI or local filename
				# Ignore for now
				# TODO
			} else if (char == "d" || char == "D" || char == "n" || char == "N") {
				# Deprecated, silently remove
			} else if (char == "i" || char == "U" || char == "F") {
				error("xdg-open: Field code %" char "must be stand alone as it expands into multiple arguments!")
			} else {
				error("xdg-open: Unknown field code: %" char " in Exec key!");
			}
		}
		if (found_file_field_codes > 1) {
			error("xdg-open: More than one file field codes (%f, %F, %u, %U) in Exec key, this .desktop file is invalid!");
		}
		expanded_args[eargc] = expanded_arg;
		eargc = eargc + 1;
	}

	if (found_file_field_codes == 0) {
		debug(1, "Didn't find a file field code (%f, %F, %u, %U), appending filepath/url as last argument");
		if (files[0]) {
			expanded_args[eargc] = files[0];
		} else {
			expanded_args[eargc] = uris[0];
		}
		eargc = eargc + 1;
	}

	printf("cmd\0");
	for (i=0; expanded_args[i]; i++) {
		debug(1, "Arg: " expanded_args[i]);
		printf("%s\0", expanded_args[i]);
	}
	exit
}
AWKEOF
)"


# (desktop_file, file, uri (optional))
open_with_desktop_file()
{
	# shellcheck disable=SC2016 # Not expanding is intended here
	awk -v"hostname=$(get_hostname)" -v"file_arg=$2" -v"uri_arg=$3" "$awk_script_open_with_desktop_file" < "$1" | xargs -0 -x sh -c 'if [ "$1" = "cmd" ] ; then shift; exec "$@" ; else exit 4 ; fi' -
	if [ "$?" -eq 123 ] ; then
		exit_failure_operation_failed
	fi
}

#(application, directory, target_file, target_url (optional))
search_desktop_file()
{
    local default="$1"
    local dir="$2"
    local target="$3"
    local target_uri="$4"

    local file=""
    # look for both vendor-app.desktop, vendor/app.desktop
    if [ -r "$dir/$default" ]; then
      file="$dir/$default"
    elif [ -r "$dir/$(echo "$default" | sed -e 's|-|/|')" ]; then
      file="$dir/$(echo "$default" | sed -e 's|-|/|')"
    fi

    if [ -r "$file" ] ; then
		open_with_desktop_file "$file" "$target" "$target_uri"
		exit_success
    fi

    for d in "$dir/"*/; do
        [ -d "$d" ] && search_desktop_file "$default" "$d" "$target" "$target_uri"
    done
}

# (file (or empty), mimetype, optional url)
open_generic_xdg_mime()
{
    filetype="$2"
    default="$(xdg-mime query default "$filetype")"
    if [ -n "$default" ] ; then
        xdg_user_dir="$XDG_DATA_HOME"
        [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"

        xdg_system_dirs="$XDG_DATA_DIRS"
        [ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/

        search_dirs="$xdg_user_dir:$xdg_system_dirs"
        DEBUG 3 "$search_dirs"
        old_ifs="$IFS"
        IFS=:
        for x in $search_dirs ; do
            IFS="$old_ifs"
            search_desktop_file "$default" "$x/applications/" "$1" "$3"
        done
    fi
}

# Open an url using the x-scheme-handler/<scheme> dummy mimetype
# (url)
open_generic_xdg_x_scheme_handler()
{
    scheme="$(echo "$1" | LC_ALL=C sed -n 's/\(^[[:alpha:]][[:alnum:]+\.-]*\):.*$/\1/p')"
    if [ -n "$scheme" ]; then
        filetype="x-scheme-handler/$scheme"
        open_generic_xdg_mime "" "$filetype" "$1"
    fi
}

# (args ...)
has_single_argument()
{
  test $# = 1
}

# Open an url or path using the BROWSER variable.
# Exits on success retuerns otherwise.
# (url_or_path)
open_envvar()
{
    local oldifs="$IFS"
    local browser

    IFS=":"
    for browser in $BROWSER; do
        IFS="$oldifs"

        if [ -z "$browser" ]; then
            continue
        fi

        if echo "$browser" | grep -q %s; then
            # Avoid argument injection.
            # See https://bugs.freedesktop.org/show_bug.cgi?id=103807
            # URIs don't have IFS characters spaces anyway.
            # shellcheck disable=SC2086,SC2091,SC2059
            # All the scary things here are intentional
            has_single_argument $1 && $(printf "$browser" "$1")
        else
            $browser "$1"
        fi

        if [ $? -eq 0 ]; then
            exit_success
        fi
    done
}

# (url_or_path)
open_wsl()
{
    local win_path
    if is_file_url_or_path "$1" ; then
        win_path="$(file_url_to_path "$1")"
        win_path="$(wslpath -aw "$win_path")"
        [ $? -eq 0 ] || exit_failure_operation_failed
        explorer.exe "${win_path}"
    else
        rundll32.exe url.dll,FileProtocolHandler "$1" 
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_generic()
{
    if is_file_url_or_path "$1"; then
        local file
        file="$(file_url_to_path "$1")"

        check_input_file "$file"

        if has_display; then
            filetype="$(xdg-mime query filetype "$file" | sed "s/;.*//")"
            # passing a path a url is okay too,
            # see desktop file specification for '%u'
			if has_url_scheme "$1" ; then
				open_generic_xdg_mime "$file" "$filetype" "$1"
			else
				open_generic_xdg_mime "$file" "$filetype"
			fi
        fi

        if command -v run-mailcap >/dev/null; then
            run-mailcap --action=view "$file"
            if [ $? -eq 0 ]; then
                exit_success
            fi
        fi

        if has_display && mimeopen -v 2>/dev/null 1>&2; then
            mimeopen -L -n "$file"
            if [ $? -eq 0 ]; then
                exit_success
            fi
        fi
    fi

    if has_display; then
        open_generic_xdg_x_scheme_handler "$1"
    fi

    if [ -n "$BROWSER" ]; then
        open_envvar "$1"
    fi

    # if BROWSER variable is not set, check some well known browsers instead
    if [ x"$BROWSER" = x"" ]; then
        BROWSER=www-browser:links2:elinks:links:lynx:w3m
        if has_display; then
            BROWSER=x-www-browser:firefox:iceweasel:seamonkey:mozilla:epiphany:konqueror:chromium:chromium-browser:google-chrome:$BROWSER
        fi
    fi

    open_envvar "$1"

    exit_failure_operation_impossible "no method available for opening '$1'"
}

# (url_or_path)
open_lxde()
{

    # pcmanfm only knows how to handle file:// urls and filepaths, it seems.
    if pcmanfm --help >/dev/null 2>&1 && is_file_url_or_path "$1"; then
        local file
        file="$(file_url_to_path "$1")"

        # handle relative paths
        if ! echo "$file" | grep -q ^/; then
            file="$(pwd)/$file"
        fi

        pcmanfm "$file"
    else
        open_generic "$1"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

# (url_or_path)
open_lxqt()
{
    if qtxdg-mat open --help 2>/dev/null 1>&2; then
        qtxdg-mat open "$1"
    else
        exit_failure_operation_impossible "no method available for opening '$1'"
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

open_one_argument()
{
    url="$1"
    case "$DE" in
        kde)
            open_kde "$url"
            ;;

        deepin)
            open_deepin "$url"
            ;;

        gnome3|cinnamon)
            open_gnome3 "$url"
            ;;

        gnome)
            open_gnome "$url"
            ;;

        mate)
            open_mate "$url"
            ;;

        xfce)
            open_xfce "$url"
            ;;

        lxde)
            open_lxde "$url"
            ;;

        lxqt)
            open_lxqt "$url"
            ;;

        enlightenment)
            open_enlightenment "$url"
            ;;

        cygwin)
            open_cygwin "$url"
            ;;

        darwin)
            open_darwin "$url"
            ;;

        flatpak|toolbx)
            open_gdbus "$url"
            ;;

        wsl)
            open_wsl "$url"
            ;;

        generic)
            open_generic "$1"
            ;;

        *)
            exit_failure_operation_impossible "no method available for opening '$1'"
            ;;
    esac
}

[ x"$1" != x"" ] || exit_failure_syntax

detectDE

if [ x"$DE" = x"" ]; then
    DE=generic
fi

DEBUG 2 "Selected DE $DE"

# sanitize BROWSER (avoid calling ourselves in particular)
case "${BROWSER}" in
    *:"xdg-open"|"xdg-open":*)
        BROWSER="$(echo "$BROWSER" | sed -e 's|:xdg-open||g' -e 's|xdg-open:||g')"
        ;;
    "xdg-open")
        BROWSER=
        ;;
esac

# Handle the URL arguments and script-specific options.
NOWAIT=0
err=0

# (arg, remaining_args)
handle_positional_arg() {
	echo "remaining: $2"
	if [ "$2" -gt 0 ] || [ "$NOWAIT" = 1 ]; then
		(open_one_argument "$1" &)
	else
		(open_one_argument "$1")
	fi
	this_err=$?
	if [ $err -eq 0 ]; then
		err=$this_err
	fi
}

while [ $# -gt 0 ]; do
    parm="$1"
    shift

    case "$parm" in
        --nowait)
            NOWAIT=1
            ;;

		--)
			break
			;;

        -*)
            exit_failure_syntax "unexpected option '$parm'"
            ;;

        *)
	        handle_positional_arg "$parm" "$#"
            ;;
    esac
done

# handle positional arguments after a --
while [ $# -gt 0 ]; do
	parm="$1"
	shift
	handle_positional_arg "$parm" "$#"
done

exit $err
