path: root/scripts/xdg-mime.in

#!/bin/sh
#---------------------------------------------
#   xdg-mime
#
#   Utility script to manipulate MIME related information
#   on XDG compliant systems.
#
#   Refer to the usage() function below for usage.
#
#   Copyright 2006, Kevin Krammer <kevin.krammer@gmx.at>
#   Copyright 2006, Jeremy White <jwhite@codeweavers.com>
#
#   LICENSE:
#
#---------------------------------------------

manualpage()
{
cat << _MANUALPAGE
_MANUALPAGE
}

usage()
{
cat << _USAGE
_USAGE
}

#@xdg-utils-common@

update_mime_database()
{
   IFS_save=$IFS
   IFS=":"
   for x in $PATH:/opt/gnome/bin; do
      if [ -x $x/update-mime-database ] ; then
         DEBUG 1 "Running $x/update-mime-database $1"
         $x/update-mime-database $1
         return
      fi
   done
   IFS=$IFS_save
}

info_kde()
{
    DEBUG 1 "Running kfile \"$1\""
    kfile "$1" 2> /dev/null | head -n 1 | cut -d "(" -f 2 | cut -d ")" -f 1

    exit_success
}

info_gnome()
{
    DEBUG 1 "Running gnomevfs-info \"$1\""
    gnomevfs-info "$1" 2> /dev/null | grep MIME | cut -d ":" -f 2 | sed s/"^ "//

    exit_success
}

info_generic()
{
    DEBUG 1 "Running /usr/bin/file -i \"$1\"" 
    /usr/bin/file -i "$1" 2> /dev/null | cut -d ":" -f 2 | sed s/"^ "//

    exit_success
}

make_default_kde()
{
    # $1 is vendor-name.desktop
    # $2 is mime/type 
    # Add to $KDE_HOME/share/config/profilerc:
    # [$2 - 1]
    # Application=$1
    #
    # Remove all [$2 - *] sections, or even better,
    # renumber [$2 - *] sections and remove duplicate
    
    default_file=$HOME/.kde/share/config/profilerc
    DEBUG 2 "make_default_kde $1 $2"
    DEBUG 1 "Updating $default_file"
    awk -v application="$1" -v mimetype="$2" '
    BEGIN {
        header_start="[" mimetype " - "
        supress=0
    }
    {  
        if (index($0, header_start) == 1 )
            supress=1
        else
            if (/^\[/) { supress=0 }

        if (!supress) {
            print $0
        }
    }
    END {
        print "" 
        print "[" mimetype " - 1]"
        print "Application=" application
        print "AllowAsDefault=true"
        print "GenericServiceType=Application"
        print "Preference=1"
        print "ServiceType=" mimetype
    }
' $default_file > ${default_file}.new && mv ${default_file}.new $default_file
}

make_default_generic()
{
    # $1 is vendor-name.desktop
    # $2 is mime/type 
    # Add $2=$1 to XDG_DATA_HOME/applications/defaults.list
    xdg_user_dir=$XDG_DATA_HOME
    [ -n "$xdg_user_dir" ] || xdg_user_dir=$HOME/.local/share
    default_file=$xdg_user_dir/applications/defaults.list
    DEBUG 2 "make_default_generic $1 $2"
    DEBUG 1 "Updating $default_file"
    grep -v "$2=" $default_file > ${default_file}.new 2> /dev/null
    if ! grep "[Default Applications]" ${default_file}.new > /dev/null; then
       echo "[Default Applications]" >> ${default_file}.new
    fi
    echo $2=$1 >> ${default_file}.new
    mv ${default_file}.new $default_file
}


defapp_kde()
{
    DEBUG 1 "Running kfile \"$1\""
    MIME=`kfile "$1" 2> /dev/null | head -n 1 | cut -d "(" -f 2 | cut -d ")" -f 1`
    DEBUG 2 "MIME = $MIME"

    if [ x"$MIME" != x"" ]; then
        DEBUG 1 "Running ktradertest \"$MIME\" Application"
        trader_result=`ktradertest "$MIME" Application 2>/dev/null | grep DesktopEntryPath \
            | head -n 1 | cut -d ':' -f 2 | cut -d \' -f 2`
        if [ -n "$trader_result" ] ; then
            basename "$trader_result"
        fi
        exit_success
    else
        exit_failure_operation_failed
    fi
}

defapp_gnome()
{
    DEBUG 1 "Running gnomevfs-info \"$1\""
    gnomevfs-info "$1" 2> /dev/null | grep "Default app" | cut -d ":" -f 2 \
        | cut -d " " -f 2

    exit_success
}


install_xsl_listmime()
{
# Dump script to file, can't pipe into xsltproc directly
xsl_file=`mktemp` || return
DEBUG 2 "Creating temporary XSL file to list mimetypes: $xsl_file"
cat > $xsl_file << _XSL
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:mime="http://www.freedesktop.org/standards/shared-mime-info">
<xsl:output method="text"
            encoding="UTF-8"
            indent="no"/>
<xsl:template match="/">
      <xsl:for-each select='mime:mime-info/mime:mime-type'>
        <xsl:value-of select="@type"/><xsl:text>&#10;</xsl:text>
      </xsl:for-each>
</xsl:template>
</xsl:stylesheet>
_XSL
}

install_xsl_shared2mimelnk()
{
# Dump script to file, can't pipe into xsltproc directly
xsl_file=`mktemp` || return
DEBUG 2 "Creating temporary XSL file to convert XML mimetype file: $xsl_file"
cat > $xsl_file << _XSL
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:mime="http://www.freedesktop.org/standards/shared-mime-info">
<xsl:output method="text"
            encoding="UTF-8"
            indent="no"/>
<xsl:template match="/">
      <xsl:for-each select='mime:mime-info/mime:mime-type[@type=\$type]'>
        <xsl:text>[Desktop Entry]&#10;</xsl:text>
        <xsl:text># Installed by xdg-mime from </xsl:text><xsl:value-of select="\$source"/><xsl:text>&#10;</xsl:text>
        <xsl:text>Type=MimeType&#10;</xsl:text>
        <xsl:text>MimeType=</xsl:text><xsl:value-of select="@type"/><xsl:text>&#10;</xsl:text>
        <xsl:text>Icon=</xsl:text><xsl:value-of select="translate(@type,'/','-')"/><xsl:text>&#10;</xsl:text>
        <xsl:if test="mime:sub-class-of">
           <xsl:text>X-KDE-IsAlso=</xsl:text><xsl:value-of select="mime:sub-class-of/@type"/><xsl:text>&#10;</xsl:text>
        </xsl:if>
        <xsl:if test="mime:glob">
          <xsl:text>Patterns=</xsl:text>
          <xsl:for-each select='mime:glob[@pattern]'>
            <xsl:value-of select="@pattern"/><xsl:text>;</xsl:text>
          </xsl:for-each>
          <xsl:text>&#10;</xsl:text>
        </xsl:if>
        <xsl:text>Comment=</xsl:text><xsl:value-of select="mime:comment[not(@xml:lang)]"/><xsl:text>&#10;</xsl:text>
        <xsl:for-each select='mime:comment[@xml:lang]'>
          <xsl:sort select='@xml:lang'/>
          <xsl:text>Comment[</xsl:text><xsl:value-of select="@xml:lang"/><xsl:text>]=</xsl:text><xsl:value-of select="."/><xsl:text>&#10;</xsl:text>
        </xsl:for-each>
     </xsl:for-each>
</xsl:template>
</xsl:stylesheet>
_XSL
}

uninstall_xsl()
{
  DEBUG 2 "Cleaning up temporary XSL file: $xsl_file"
  rm -f $xsl_file
  xsl_file=
}


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

mode=
action=
filename=

case $1 in
  install)
    action=install
    ;;

  uninstall)
    action=uninstall
    ;;

  query)
    shift

    if [ -z "$1" ] ; then 
        exit_failure_syntax "query type argument missing"
    fi
    
    case $1 in
      filetype)
        action=info
        ;;

      default)
        action=defapp
        ;;

      *)
      exit_failure_syntax "unknown query type '$1'"
      ;;
    esac
    ;;

  default)
    action=makedefault
    shift

    if [ -z "$1" ] ; then 
        exit_failure_syntax "application argument missing"
    fi
    case $1 in
      -*)
        exit_failure_syntax "unexpected option '$1'"
        ;;

      *.desktop)
        filename=$1
        ;;

      *)
        exit_failure_syntax "malformed argument '$1', expected *.desktop"
        ;;
    esac
    ;;

  *)
  exit_failure_syntax "unknown command '$1'"
  ;;
esac

shift


if [ "$action" = "makedefault" ]; then
    if [ -z "$1" ] ; then 
        exit_failure_syntax "mimetype argument missing"
    fi

    while [ $# -gt 0 ] ; do
        case $1 in
          -*)
            exit_failure_syntax "unexpected option '$1'"
            ;;
        esac
        mimetype=$1
        shift
        
        make_default_kde "$filename" "$mimetype"
        make_default_generic "$filename" "$mimetype"
    done
    exit_success
fi

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

    case $parm in
      --user)
        mode=user
        ;;

      --system)
        mode=system
        ;;

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

      *)
        if [ -n "$filename" ] ; then
            exit_failure_syntax "unexpected argument '$parm'"
        fi
        if [ ! -f "$parm" ] ; then
            exit_failure_file_missing "file '$parm' does not exist"
        fi
        filename=$parm
        ;;
    esac
done

if [ -z "$action" ] ; then
    exit_failure_syntax "command argument missing"
fi

if [ "$action" = "info" ]; then
    if [ -n "$mode" ] ; then
        exit_failure_syntax "unexpected option '--$mode'"
    fi
    if [ -z "$filename" ] ; then
        exit_failure_syntax "FILE argument missing"
    fi

    detectDE

    if [ x"$DE" = x"" ]; then
        if [ -x /usr/bin/file ]; then
            DE=generic
        fi
    fi

    case "$DE" in
        kde)
        info_kde "$filename"
        ;;

        gnome)
        info_gnome "$filename"
        ;;

        generic)
        info_generic "$filename"
        ;;
    esac
    exit_failure_operation_impossible "no method available for quering MIME type of '$filename'"
fi

if [ "$action" = "defapp" ]; then
    if [ -n "$mode" ] ; then
        exit_failure_syntax "unexpected option '--$mode'"
    fi
    if [ -z "$filename" ] ; then
        exit_failure_syntax "FILE argument missing"
    fi

    detectDE

    case "$DE" in
        kde)
        defapp_kde "$filename"
        ;;

        gnome)
        defapp_gnome "$filename"
        ;;
    esac
    exit_failure_operation_impossible "no method available for quering default application for file '$filename'"
fi

if [ -z "$mode" ] ; then
    exit_failure_syntax "expected --user or --system option"
fi
if [ -z "$filename" ] ; then
    exit_failure_syntax "mimetypes-file argument missing"
fi

xdg_base_dir=
xdg_dir_name=mime/packages/

xdg_user_dir=$XDG_DATA_HOME
[ -n "$xdg_user_dir" ] || xdg_user_dir=$HOME/.local/share
[ x"$mode" = x"user" ] && xdg_base_dir=$xdg_user_dir/mime
xdg_user_dir=$xdg_user_dir/$xdg_dir_name

xdg_system_dirs=$XDG_DATA_DIRS
[ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
IFS_save=$IFS
IFS=":"
for x in $xdg_system_dirs ; do
    if [ -w $x/$xdg_dir_name ] ; then
        [ x"$mode" = x"system" ] && xdg_base_dir=$x/mime
        xdg_global_dir=$x/$xdg_dir_name
        break
    fi
done
IFS=$IFS_save
[ -w $xdg_global_dir ] || xdg_global_dir=
DEBUG 3 "xdg_user_dir: $xdg_user_dir"
DEBUG 3 "xdg_global_dir: $xdg_global_dir"

# Find KDE3 mimelnk directory
kde_user_dir=$HOME/.kde/share/mimelnk
kde_global_dir=
kde_global_dirs=`kde-config --path mime`
DEBUG 3 "kde_global_dirs: $kde_global_dirs"
[ -n $kde_global_dirs ] || kde_global_dirs=/opt/kde3/share/mimelnk:/opt/kde/share/mimelnk:/usr/share/mimelnk
IFS_save=$IFS
IFS=":"
first=
for x in $kde_global_dirs ; do
    if [ -z "$first" ] ; then
        first=false
        #TODO: Mode check seems redundant
        [ x"$mode" = x"user" ] && kde_user_dir=$x
    elif [ -w $x ] ; then
        [ x"$mode" = x"system" ] && kde_global_dir=$x
    fi
done
IFS=$IFS_save
DEBUG 3 "kde_user_dir: $kde_user_dir"
DEBUG 3 "kde_global_dir: $kde_global_dir"

# TODO: Gnome legacy support
# See http://forums.fedoraforum.org/showthread.php?t=26875
gnome_user_dir=$HOME/.gnome/apps
gnome_global_dir=/usr/share/gnome/apps
[ -w $gnome_global_dir ] || gnome_global_dir=
DEBUG 3 "gnome_user_dir: $gnome_user_dir"
DEBUG 3 "gnome_global_dir: $gnome_global_dir"

if [ x"$mode" = x"user" ] ; then
    xdg_dir=$xdg_user_dir
    kde_dir=$kde_user_dir
    gnome_dir=$gnome_user_dir
    my_umask=077
else
    xdg_dir=$xdg_global_dir
    kde_dir=$kde_global_dir
    gnome_dir=$gnome_global_dir
    my_umask=022
    if [ -z "${xdg_dir}${kde_dir}${gnome_dir}" ] ; then
        [ `whoami` = "root" ] || rootmsg="Try as root or use --user."
        exit_failure_operation_impossible "No writable system mimetype directory found. $rootmsg"
    fi
fi

# echo "[xdg|$xdg_user_dir|$xdg_global_dir]"
# echo "[kde|$kde_user_dir|$kde_global_dir]"
# echo "[gnome|$gnome_user_dir|$gnome_global_dir]"
# echo "[using|$xdg_dir|$kde_dir|$gnome_dir]"

basefile=`basename "$filename"`
#[ -z $vendor ] || basefile=$vendor-$basefile

mimetypes=
if [ -n "$kde_dir" ] ; then
    DEBUG 2 "KDE3 mimelnk directory found, extracting mimetypes from XML file"
    install_xsl_listmime
    DEBUG 1 "Running xsltproc \"$xsl_file\" \"$filename\""
    mimetypes=`xsltproc "$xsl_file" "$filename"`
    uninstall_xsl
fi  

DEBUG 1 "$action mimetype in $xdg_dir"

case $action in
    install)
        save_umask=`umask`
        umask $my_umask

        for x in $xdg_dir ; do
            mkdir -p $x
            cp $filename $x/$basefile
        done

        if [ -n "$mimetypes" ] ; then
            install_xsl_shared2mimelnk
        
            IFS_save=$IFS
            IFS='
'
            for x in $mimetypes ; do 
                DEBUG 1 "Installing $kde_dir/$x.desktop (KDE 3.x support)"
                xsltproc --stringparam type $x --stringparam source $basefile $xsl_file $filename > $kde_dir/$x.desktop
            done
            IFS=$IFS_save

            uninstall_xsl
        fi

        umask $save_umask
        ;;

    uninstall)
        for x in $xdg_dir ; do
            rm -f $x/$basefile
        done

        IFS_save=$IFS
        IFS='
'
        for x in $mimetypes ; do 
            if grep '^# Installed by xdg-mime' $kde_dir/$x.desktop &>/dev/null ; then
                DEBUG 1 "Removing $kde_dir/$x.desktop (KDE 3.x support)"
                rm -f $kde_dir/$x.desktop
            fi
        done
        IFS=$IFS_save

        ;;
esac

update_mime_database $xdg_base_dir

exit_success