~willismonroe/ubuntu/precise/xdg-utils/typo-fix-996304

« back to all changes in this revision

Viewing changes to .pc/xdg-mime-follow-symlinks.diff/scripts/xdg-mime

  • Committer: Bazaar Package Importer
  • Author(s): Per Olofsson
  • Date: 2011-02-20 18:34:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110220183453-7p0edr23dygfhseg
Tags: 1.1.0~rc1-2
* Tag patches with upstream bug URLs.
* Add patch xdg-mime-follow-symlinks.diff: Follow symlinks when
  querying MIME type in xdg-mime.
* Add patch xdg-open-browser-multiword.diff: Fix support for multi-word
  $BROWSER commands. Closes: #612339.
* Add patch xdg-open-printf.diff: Use /usr/bin/printf if available when
  decoding URLs. dash's printf doesn't understand \xHH
  sequences. Closes: #613272.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#!/bin/sh
 
2
#---------------------------------------------
 
3
#   xdg-mime
 
4
#
 
5
#   Utility script to manipulate MIME related information
 
6
#   on XDG compliant systems.
 
7
#
 
8
#   Refer to the usage() function below for usage.
 
9
#
 
10
#   Copyright 2009-2010, Fathi Boudra <fabo@freedesktop.org>
 
11
#   Copyright 2009-2010, Rex Dieter <rdieter@fedoraproject.org>
 
12
#   Copyright 2006, Kevin Krammer <kevin.krammer@gmx.at>
 
13
#   Copyright 2006, Jeremy White <jwhite@codeweavers.com>
 
14
#
 
15
#   LICENSE:
 
16
#
 
17
#   Permission is hereby granted, free of charge, to any person obtaining a
 
18
#   copy of this software and associated documentation files (the "Software"),
 
19
#   to deal in the Software without restriction, including without limitation
 
20
#   the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
21
#   and/or sell copies of the Software, and to permit persons to whom the
 
22
#   Software is furnished to do so, subject to the following conditions:
 
23
#
 
24
#   The above copyright notice and this permission notice shall be included
 
25
#   in all copies or substantial portions of the Software.
 
26
#
 
27
#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
28
#   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
29
#   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
30
#   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 
31
#   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 
32
#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 
33
#   OTHER DEALINGS IN THE SOFTWARE.
 
34
#
 
35
#---------------------------------------------
 
36
 
 
37
manualpage()
 
38
{
 
39
cat << _MANUALPAGE
 
40
Name
 
41
 
 
42
xdg-mime - command line tool for querying information about file type handling
 
43
and adding descriptions for new file types
 
44
 
 
45
Synopsis
 
46
 
 
47
xdg-mime query { filetype | default } ...
 
48
 
 
49
xdg-mime default application mimetype(s)
 
50
 
 
51
xdg-mime install [--mode mode] [--novendor] mimetypes-file
 
52
 
 
53
xdg-mime uninstall [--mode mode] mimetypes-file
 
54
 
 
55
xdg-mime { --help | --manual | --version }
 
56
 
 
57
Description
 
58
 
 
59
The xdg-mime program can be used to query information about file types and to
 
60
add descriptions for new file types.
 
61
 
 
62
Commands
 
63
 
 
64
query
 
65
 
 
66
    Returns information related to file types.
 
67
 
 
68
    The query option is for use inside a desktop session only. It is not
 
69
    recommended to use xdg-mime query as root.
 
70
 
 
71
    The following queries are supported:
 
72
 
 
73
    query filetype FILE: Returns the file type of FILE in the form of a MIME
 
74
    type.
 
75
 
 
76
    query default mimetype: Returns the default application that the desktop
 
77
    environment uses for opening files of type mimetype. The default
 
78
    application is identified by its *.desktop file.
 
79
 
 
80
default
 
81
 
 
82
    Ask the desktop environment to make application the default application for
 
83
    opening files of type mimetype. An application can be made the default for
 
84
    several file types by specifying multiple mimetypes.
 
85
 
 
86
    application is the desktop file id of the application and has the form
 
87
    vendor-name.desktop application must already be installed in the desktop
 
88
    menu before it can be made the default handler. The aplication's desktop
 
89
    file must list support for all the MIME types that it wishes to be the
 
90
    default handler for.
 
91
 
 
92
    Requests to make an application a default handler may be subject to system
 
93
    policy or approval by the end-user. xdg-mime query can be used to verify
 
94
    whether an application is the actual default handler for a specific file
 
95
    type.
 
96
 
 
97
    The default option is for use inside a desktop session only. It is not
 
98
    recommended to use xdg-mime default as root.
 
99
 
 
100
install
 
101
    Adds the file type descriptions provided in mimetypes-file to the desktop
 
102
    environment. mimetypes-file must be a XML file that follows the
 
103
    freedesktop.org Shared MIME-info Database specification and that has a
 
104
    mime-info element as its document root. For each new file type one or more
 
105
    icons with name type-subtype must be installed with the xdg-icon-resource
 
106
    command in the mimetypes context. For example the filetype application/
 
107
    vnd.oasis.opendocument.text requires an icon named
 
108
    application-vnd.oasis.opendocument.text to be installed (unless the file
 
109
    type recommends another icon name).
 
110
uninstall
 
111
    Removes the file type descriptions provided in mimetypes-file and
 
112
    previously added with xdg-mime install from the desktop environment.
 
113
    mimetypes-file must be a XML file that follows the freedesktop.org Shared
 
114
    MIME-info Database specification and that has a mime-info element as its
 
115
    document root.
 
116
 
 
117
Options
 
118
 
 
119
--mode mode
 
120
 
 
121
    mode can be user or system. In user mode the file is (un)installed for the
 
122
    current user only. In system mode the file is (un)installed for all users
 
123
    on the system. Usually only root is allowed to install in system mode.
 
124
 
 
125
    The default is to use system mode when called by root and to use user mode
 
126
    when called by a non-root user.
 
127
 
 
128
--novendor
 
129
 
 
130
    Normally, xdg-mime checks to ensure that the mimetypes-file to be installed
 
131
    has a proper vendor prefix. This option can be used to disable that check.
 
132
 
 
133
    A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated
 
134
    with a dash ("-"). Companies and organizations are encouraged to use a word
 
135
    or phrase, preferably the organizations name, for which they hold a
 
136
    trademark as their vendor prefix. The purpose of the vendor prefix is to
 
137
    prevent name conflicts.
 
138
 
 
139
--help
 
140
    Show command synopsis.
 
141
--manual
 
142
    Show this manualpage.
 
143
--version
 
144
    Show the xdg-utils version information.
 
145
 
 
146
Environment Variables
 
147
 
 
148
xdg-mime honours the following environment variables:
 
149
 
 
150
XDG_UTILS_DEBUG_LEVEL
 
151
    Setting this environment variable to a non-zero numerical value makes
 
152
    xdg-mime do more verbose reporting on stderr. Setting a higher value
 
153
    increases the verbosity.
 
154
XDG_UTILS_INSTALL_MODE
 
155
    This environment variable can be used by the user or administrator to
 
156
    override the installation mode. Valid values are user and system.
 
157
 
 
158
Exit Codes
 
159
 
 
160
An exit code of 0 indicates success while a non-zero exit code indicates
 
161
failure. The following failure codes can be returned:
 
162
 
 
163
1
 
164
    Error in command line syntax.
 
165
2
 
166
    One of the files passed on the command line did not exist.
 
167
3
 
168
    A required tool could not be found.
 
169
4
 
170
    The action failed.
 
171
5
 
172
    No permission to read one of the files passed on the command line.
 
173
 
 
174
See Also
 
175
 
 
176
xdg-icon-resource(1), xdg-desktop-menu(1)
 
177
 
 
178
Examples
 
179
 
 
180
xdg-mime query filetype /tmp/foobar.png
 
181
 
 
182
Prints the MIME type of the file /tmp/foobar.png, in this case image/png
 
183
 
 
184
xdg-mime query default image/png
 
185
 
 
186
Prints the .desktop filename of the application which is registered to open PNG
 
187
files.
 
188
 
 
189
xdg-mime install shinythings-shiny.xml
 
190
 
 
191
Adds a file type description for "shiny"-files. "shinythings-" is used as the
 
192
vendor prefix. The file type description could look as folows.
 
193
 
 
194
shinythings-shiny.xml:
 
195
 
 
196
<?xml version="1.0"?>
 
197
<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
 
198
  <mime-type type="text/x-shiny">
 
199
    <comment>Shiny new file type</comment>
 
200
    <glob pattern="*.shiny"/>
 
201
    <glob pattern="*.shi"/>
 
202
  </mime-type>
 
203
</mime-info>
 
204
 
 
205
An icon for this new file type must also be installed, for example with:
 
206
 
 
207
xdg-icon-resource install --context mimetypes --size 64 shiny-file-icon.png text-x-shiny
 
208
 
 
209
_MANUALPAGE
 
210
}
 
211
 
 
212
usage()
 
213
{
 
214
cat << _USAGE
 
215
xdg-mime - command line tool for querying information about file type handling
 
216
and adding descriptions for new file types
 
217
 
 
218
Synopsis
 
219
 
 
220
xdg-mime query { filetype | default } ...
 
221
 
 
222
xdg-mime default application mimetype(s)
 
223
 
 
224
xdg-mime install [--mode mode] [--novendor] mimetypes-file
 
225
 
 
226
xdg-mime uninstall [--mode mode] mimetypes-file
 
227
 
 
228
xdg-mime { --help | --manual | --version }
 
229
 
 
230
_USAGE
 
231
}
 
232
 
 
233
#@xdg-utils-common@
 
234
 
 
235
#----------------------------------------------------------------------------
 
236
#   Common utility functions included in all XDG wrapper scripts
 
237
#----------------------------------------------------------------------------
 
238
 
 
239
DEBUG()
 
240
{
 
241
  [ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && return 0;
 
242
  [ ${XDG_UTILS_DEBUG_LEVEL} -lt $1 ] && return 0;
 
243
  shift
 
244
  echo "$@" >&2
 
245
}
 
246
 
 
247
#-------------------------------------------------------------
 
248
# Exit script on successfully completing the desired operation
 
249
 
 
250
exit_success()
 
251
{
 
252
    if [ $# -gt 0 ]; then
 
253
        echo "$@"
 
254
        echo
 
255
    fi
 
256
 
 
257
    exit 0
 
258
}
 
259
 
 
260
 
 
261
#-----------------------------------------
 
262
# Exit script on malformed arguments, not enough arguments
 
263
# or missing required option.
 
264
# prints usage information
 
265
 
 
266
exit_failure_syntax()
 
267
{
 
268
    if [ $# -gt 0 ]; then
 
269
        echo "xdg-mime: $@" >&2
 
270
        echo "Try 'xdg-mime --help' for more information." >&2
 
271
    else
 
272
        usage
 
273
        echo "Use 'man xdg-mime' or 'xdg-mime --manual' for additional info."
 
274
    fi
 
275
 
 
276
    exit 1
 
277
}
 
278
 
 
279
#-------------------------------------------------------------
 
280
# Exit script on missing file specified on command line
 
281
 
 
282
exit_failure_file_missing()
 
283
{
 
284
    if [ $# -gt 0 ]; then
 
285
        echo "xdg-mime: $@" >&2
 
286
    fi
 
287
 
 
288
    exit 2
 
289
}
 
290
 
 
291
#-------------------------------------------------------------
 
292
# Exit script on failure to locate necessary tool applications
 
293
 
 
294
exit_failure_operation_impossible()
 
295
{
 
296
    if [ $# -gt 0 ]; then
 
297
        echo "xdg-mime: $@" >&2
 
298
    fi
 
299
 
 
300
    exit 3
 
301
}
 
302
 
 
303
#-------------------------------------------------------------
 
304
# Exit script on failure returned by a tool application
 
305
 
 
306
exit_failure_operation_failed()
 
307
{
 
308
    if [ $# -gt 0 ]; then
 
309
        echo "xdg-mime: $@" >&2
 
310
    fi
 
311
 
 
312
    exit 4
 
313
}
 
314
 
 
315
#------------------------------------------------------------
 
316
# Exit script on insufficient permission to read a specified file
 
317
 
 
318
exit_failure_file_permission_read()
 
319
{
 
320
    if [ $# -gt 0 ]; then
 
321
        echo "xdg-mime: $@" >&2
 
322
    fi
 
323
 
 
324
    exit 5
 
325
}
 
326
 
 
327
#------------------------------------------------------------
 
328
# Exit script on insufficient permission to write a specified file
 
329
 
 
330
exit_failure_file_permission_write()
 
331
{
 
332
    if [ $# -gt 0 ]; then
 
333
        echo "xdg-mime: $@" >&2
 
334
    fi
 
335
 
 
336
    exit 6
 
337
}
 
338
 
 
339
check_input_file()
 
340
{
 
341
    if [ ! -e "$1" ]; then
 
342
        exit_failure_file_missing "file '$1' does not exist"
 
343
    fi
 
344
    if [ ! -r "$1" ]; then
 
345
        exit_failure_file_permission_read "no permission to read file '$1'"
 
346
    fi
 
347
}
 
348
 
 
349
check_vendor_prefix()
 
350
{
 
351
    file_label="$2"
 
352
    [ -n "$file_label" ] || file_label="filename"
 
353
    file=`basename "$1"`
 
354
    case "$file" in
 
355
       [a-zA-Z]*-*)
 
356
         return
 
357
         ;;
 
358
    esac
 
359
 
 
360
    echo "xdg-mime: $file_label '$file' does not have a proper vendor prefix" >&2
 
361
    echo 'A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated' >&2
 
362
    echo 'with a dash ("-"). An example '"$file_label"' is '"'example-$file'" >&2
 
363
    echo "Use --novendor to override or 'xdg-mime --manual' for additional info." >&2
 
364
    exit 1
 
365
}
 
366
 
 
367
check_output_file()
 
368
{
 
369
    # if the file exists, check if it is writeable
 
370
    # if it does not exists, check if we are allowed to write on the directory
 
371
    if [ -e "$1" ]; then
 
372
        if [ ! -w "$1" ]; then
 
373
            exit_failure_file_permission_write "no permission to write to file '$1'"
 
374
        fi
 
375
    else
 
376
        DIR=`dirname "$1"`
 
377
        if [ ! -w "$DIR" -o ! -x "$DIR" ]; then
 
378
            exit_failure_file_permission_write "no permission to create file '$1'"
 
379
        fi
 
380
    fi
 
381
}
 
382
 
 
383
#----------------------------------------
 
384
# Checks for shared commands, e.g. --help
 
385
 
 
386
check_common_commands()
 
387
{
 
388
    while [ $# -gt 0 ] ; do
 
389
        parm="$1"
 
390
        shift
 
391
 
 
392
        case "$parm" in
 
393
            --help)
 
394
            usage
 
395
            echo "Use 'man xdg-mime' or 'xdg-mime --manual' for additional info."
 
396
            exit_success
 
397
            ;;
 
398
 
 
399
            --manual)
 
400
            manualpage
 
401
            exit_success
 
402
            ;;
 
403
 
 
404
            --version)
 
405
            echo "xdg-mime 1.0.2"
 
406
            exit_success
 
407
            ;;
 
408
        esac
 
409
    done
 
410
}
 
411
 
 
412
check_common_commands "$@"
 
413
 
 
414
[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && unset XDG_UTILS_DEBUG_LEVEL;
 
415
if [ ${XDG_UTILS_DEBUG_LEVEL-0} -lt 1 ]; then
 
416
    # Be silent
 
417
    xdg_redirect_output=" > /dev/null 2> /dev/null"
 
418
else
 
419
    # All output to stderr
 
420
    xdg_redirect_output=" >&2"
 
421
fi
 
422
 
 
423
#--------------------------------------
 
424
# Checks for known desktop environments
 
425
# set variable DE to the desktop environments name, lowercase
 
426
 
 
427
detectDE()
 
428
{
 
429
    if [ x"$KDE_FULL_SESSION" = x"true" ]; then DE=kde;
 
430
    elif [ x"$GNOME_DESKTOP_SESSION_ID" != x"" ]; then DE=gnome;
 
431
    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;
 
432
    elif xprop -root _DT_SAVE_MODE 2> /dev/null | grep ' = \"xfce4\"$' >/dev/null 2>&1; then DE=xfce;
 
433
    elif [ x"$DESKTOP_SESSION" == x"LXDE" ]; then DE=lxde;
 
434
    else DE=""
 
435
    fi
 
436
}
 
437
 
 
438
#----------------------------------------------------------------------------
 
439
# kfmclient exec/openURL can give bogus exit value in KDE <= 3.5.4
 
440
# It also always returns 1 in KDE 3.4 and earlier
 
441
# Simply return 0 in such case
 
442
 
 
443
kfmclient_fix_exit_code()
 
444
{
 
445
    version=`kde${KDE_SESSION_VERSION}-config --version 2>/dev/null | grep '^KDE'`
 
446
    major=`echo $version | sed 's/KDE.*: \([0-9]\).*/\1/'`
 
447
    minor=`echo $version | sed 's/KDE.*: [0-9]*\.\([0-9]\).*/\1/'`
 
448
    release=`echo $version | sed 's/KDE.*: [0-9]*\.[0-9]*\.\([0-9]\).*/\1/'`
 
449
    test "$major" -gt 3 && return $1
 
450
    test "$minor" -gt 5 && return $1
 
451
    test "$release" -gt 4 && return $1
 
452
    return 0
 
453
}
 
454
 
 
455
update_mime_database()
 
456
{
 
457
   if [ x"$mode" = x"user" -a -n "$DISPLAY" ] ; then
 
458
      detectDE
 
459
      if [ x"$DE" = x"kde" ] ; then
 
460
         DEBUG 1 "Running kbuildsycoca"
 
461
         if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
 
462
             eval 'kbuildsycoca4'$xdg_redirect_output
 
463
         else
 
464
             eval 'kbuildsycoca'$xdg_redirect_output
 
465
         fi
 
466
      fi
 
467
   fi
 
468
   for x in `echo "$PATH:/opt/gnome/bin" | sed 's/:/ /g'`; do
 
469
      if [ -x $x/update-mime-database ] ; then
 
470
         DEBUG 1 "Running $x/update-mime-database $1"
 
471
         eval '$x/update-mime-database $1'$xdg_redirect_output
 
472
         return
 
473
      fi
 
474
   done
 
475
}
 
476
 
 
477
info_kde()
 
478
{
 
479
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
 
480
        DEBUG 1 "Running kmimetypefinder \"$1\""
 
481
        KMIMETYPEFINDER=`which kmimetypefinder 2>/dev/null`
 
482
        $KMIMETYPEFINDER "$1" 2>/dev/null | head -n 1
 
483
    else
 
484
        DEBUG 1 "Running kfile \"$1\""
 
485
        KFILE=`which kfile 2>/dev/null`
 
486
        $KFILE "$1" 2> /dev/null | head -n 1 | cut -d "(" -f 2 | cut -d ")" -f 1
 
487
    fi
 
488
 
 
489
    if [ $? -eq 0 ]; then
 
490
        exit_success
 
491
    else
 
492
        exit_failure_operation_failed
 
493
    fi
 
494
}
 
495
 
 
496
info_gnome()
 
497
{
 
498
    file=`readlink -f "$1"` # Normalize path
 
499
 
 
500
    if gvfs-info --help 2>/dev/null 1>&2; then
 
501
        DEBUG 1 "Running gvfs-info \"$file\""
 
502
        gvfs-info "$file" 2> /dev/null | grep standard::content-type | cut -d' ' -f4
 
503
    else
 
504
       DEBUG 1 "Running gnomevfs-info \"$file\""
 
505
       gnomevfs-info --slow-mime "$file" 2> /dev/null | grep "^MIME" | cut -d ":" -f 2 | sed s/"^ "//
 
506
    fi
 
507
 
 
508
    if [ $? -eq 0 ]; then
 
509
        exit_success
 
510
    else
 
511
        exit_failure_operation_failed
 
512
    fi
 
513
}
 
514
 
 
515
info_generic()
 
516
{
 
517
    DEBUG 1 "Running file -i \"$1\""
 
518
    /usr/bin/file -i "$1" 2> /dev/null | cut -d ":" -f 2 | sed s/"^ "//
 
519
 
 
520
    if [ $? -eq 0 ]; then
 
521
        exit_success
 
522
    else
 
523
        exit_failure_operation_failed
 
524
    fi
 
525
}
 
526
 
 
527
make_default_kde()
 
528
{
 
529
    # $1 is vendor-name.desktop
 
530
    # $2 is mime/type
 
531
    #
 
532
    # On KDE 3, add to $KDE_CONFIG_PATH/profilerc:
 
533
    # [$2 - 1]
 
534
    # Application=$1
 
535
    #
 
536
    # Remove all [$2 - *] sections, or even better,
 
537
    # renumber [$2 - *] sections and remove duplicate
 
538
    #
 
539
    # On KDE 4, add $2=$1 to $XDG_DATA_APPS/mimeapps.list
 
540
    #
 
541
    # Example file:
 
542
    #
 
543
    # [Added Associations]
 
544
    # text/plain=kde4-kate.desktop;kde4-kwrite.desktop;
 
545
    #
 
546
    # [Removed Associations]
 
547
    # text/plain=gnome-gedit.desktop;gnu-emacs.desktop;
 
548
    vendor="$1"
 
549
    mimetype="$2"
 
550
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
 
551
        default_dir=`kde4-config --path xdgdata-apps 2> /dev/null | cut -d ':' -f 1`
 
552
        default_file="$default_dir/mimeapps.list"
 
553
    else
 
554
        default_dir=`kde-config --path config 2> /dev/null | cut -d ':' -f 1`
 
555
        default_file="$default_dir/profilerc"
 
556
    fi
 
557
    if [ -z "$default_dir" ]; then
 
558
        DEBUG 2 "make_default_kde: No kde runtime detected"
 
559
        return
 
560
    fi
 
561
    DEBUG 2 "make_default_kde $vendor $mimetype"
 
562
    DEBUG 1 "Updating $default_file"
 
563
    mkdir -p "$default_dir"
 
564
    [ -f $default_file ] || touch $default_file
 
565
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
 
566
        [ -f $default_file ] || touch $default_file
 
567
        awk -v application="$vendor" -v mimetype="$mimetype" '
 
568
    BEGIN {
 
569
        prefix=mimetype "="
 
570
        associations=0
 
571
        found=0
 
572
        blanks=0
 
573
    }
 
574
    {
 
575
        suppress=0
 
576
        if (index($0, "[Added Associations]") == 1) {
 
577
            associations=1
 
578
        } else if (index($0, "[") == 1) {
 
579
            if (associations && !found) {
 
580
                print prefix application
 
581
                found=1
 
582
            }
 
583
            associations=0
 
584
        } else if ($0 == "") {
 
585
            blanks++
 
586
            suppress=1
 
587
        } else if (associations && index($0, prefix) == 1) {
 
588
            value=substr($0, length(prefix) + 1, length)
 
589
            split(value, apps, ";")
 
590
            value=application ";"
 
591
            count=0
 
592
            for (i in apps) {
 
593
              count++
 
594
            }
 
595
            for (i=0; i < count; i++) {
 
596
                if (apps[i] != application && apps[i] != "") {
 
597
                    value=value apps[i] ";"
 
598
                }
 
599
            }
 
600
            $0=prefix value
 
601
            found=1
 
602
        }
 
603
        if (!suppress) {
 
604
            while (blanks > 0) {
 
605
                print ""
 
606
                blanks--
 
607
            }
 
608
            print $0
 
609
        }
 
610
    }
 
611
    END {
 
612
        if (!found) {
 
613
            if (!associations) {
 
614
                print "[Added Associations]"
 
615
            }
 
616
            print prefix application
 
617
        }
 
618
        while (blanks > 0) {
 
619
            print ""
 
620
            blanks--
 
621
        }
 
622
    }
 
623
' $default_file > ${default_file}.new && mv ${default_file}.new $default_file
 
624
        eval 'kbuildsycoca4'$xdg_redirect_output
 
625
    else
 
626
        awk -v application="$vendor" -v mimetype="$mimetype" '
 
627
    BEGIN {
 
628
        header_start="[" mimetype " - "
 
629
        suppress=0
 
630
    }
 
631
    {
 
632
        if (index($0, header_start) == 1 )
 
633
            suppress=1
 
634
        else
 
635
            if (/^\[/) { suppress=0 }
 
636
 
 
637
        if (!suppress) {
 
638
            print $0
 
639
        }
 
640
    }
 
641
    END {
 
642
        print ""
 
643
        print "[" mimetype " - 1]"
 
644
        print "Application=" application
 
645
        print "AllowAsDefault=true"
 
646
        print "GenericServiceType=Application"
 
647
        print "Preference=1"
 
648
        print "ServiceType=" mimetype
 
649
    }
 
650
' $default_file > ${default_file}.new && mv ${default_file}.new $default_file
 
651
    fi
 
652
}
 
653
 
 
654
make_default_generic()
 
655
{
 
656
    # $1 is vendor-name.desktop
 
657
    # $2 is mime/type
 
658
    # Add $2=$1 to XDG_DATA_HOME/applications/defaults.list
 
659
    xdg_user_dir="$XDG_DATA_HOME"
 
660
    [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
 
661
    default_file="$xdg_user_dir/applications/defaults.list"
 
662
    DEBUG 2 "make_default_generic $1 $2"
 
663
    DEBUG 1 "Updating $default_file"
 
664
    grep -v "$2=" $default_file > ${default_file}.new 2> /dev/null
 
665
    if ! grep "[Default Applications]" ${default_file}.new > /dev/null; then
 
666
       echo "[Default Applications]" >> ${default_file}.new
 
667
    fi
 
668
    echo $2=$1 >> ${default_file}.new
 
669
    mv ${default_file}.new $default_file
 
670
}
 
671
 
 
672
defapp_generic()
 
673
{
 
674
    MIME="$1"
 
675
    xdg_user_dir="$XDG_DATA_HOME"
 
676
    [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
 
677
    xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
 
678
    xdg_system_dirs="$XDG_DATA_DIRS"
 
679
    [ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
 
680
 
 
681
    for x in `echo "$xdg_user_dir:$xdg_system_dirs" | sed 's/:/ /g'`; do
 
682
       DEBUG 2 "Checking $x/applications/defaults.list"
 
683
       trader_result=`grep "$MIME=" $x/applications/defaults.list 2> /dev/null | cut -d '=' -f 2 | cut -d ';' -f 1`
 
684
       if [ -n "$trader_result" ] ; then
 
685
          echo $trader_result
 
686
          exit_success
 
687
       fi
 
688
    done
 
689
    exit_success
 
690
}
 
691
 
 
692
defapp_kde()
 
693
{
 
694
    MIME="$1"
 
695
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
 
696
        KTRADER=`which ktraderclient 2> /dev/null`
 
697
        MIMETYPE="--mimetype"
 
698
        SERVICETYPE="--servicetype"
 
699
    else
 
700
        KTRADER=`which ktradertest 2> /dev/null`
 
701
    fi
 
702
    if [ -n "$KTRADER" ] ; then
 
703
        DEBUG 1 "Running KDE trader query \"$MIME\" mimetype and \"Application\" servicetype"
 
704
        trader_result=`$KTRADER $MIMETYPE "$MIME" $SERVICETYPE Application 2>/dev/null \
 
705
            | grep DesktopEntryPath | head -n 1 | cut -d ':' -f 2 | cut -d \' -f 2`
 
706
        if [ -n "$trader_result" ] ; then
 
707
            basename "$trader_result"
 
708
            exit_success
 
709
        else
 
710
            exit_failure_operation_failed
 
711
        fi
 
712
    else
 
713
        defapp_generic "$1"
 
714
    fi
 
715
}
 
716
 
 
717
[ x"$1" != x"" ] || exit_failure_syntax
 
718
 
 
719
mode=
 
720
action=
 
721
filename=
 
722
mimetype=
 
723
 
 
724
case $1 in
 
725
  install)
 
726
    action=install
 
727
    ;;
 
728
 
 
729
  uninstall)
 
730
    action=uninstall
 
731
    ;;
 
732
 
 
733
  query)
 
734
    shift
 
735
 
 
736
    if [ -z "$1" ] ; then
 
737
        exit_failure_syntax "query type argument missing"
 
738
    fi
 
739
 
 
740
    case $1 in
 
741
      filetype)
 
742
        action=info
 
743
 
 
744
        filename="$2"
 
745
        if [ -z "$filename" ] ; then
 
746
            exit_failure_syntax "FILE argument missing"
 
747
        fi
 
748
        case $filename in
 
749
          -*)
 
750
            exit_failure_syntax "unexpected option '$filename'"
 
751
            ;;
 
752
        esac
 
753
        check_input_file "$filename"
 
754
        ;;
 
755
 
 
756
      default)
 
757
        action=defapp
 
758
        mimetype="$2"
 
759
        if [ -z "$mimetype" ] ; then
 
760
            exit_failure_syntax "mimetype argument missing"
 
761
        fi
 
762
        case $mimetype in
 
763
          -*)
 
764
            exit_failure_syntax "unexpected option '$mimetype'"
 
765
            ;;
 
766
 
 
767
          */*)
 
768
            # Ok
 
769
            ;;
 
770
 
 
771
          *)
 
772
            exit_failure_syntax "mimetype '$mimetype' is not in the form 'minor/major'"
 
773
            ;;
 
774
        esac
 
775
        ;;
 
776
 
 
777
      *)
 
778
      exit_failure_syntax "unknown query type '$1'"
 
779
      ;;
 
780
    esac
 
781
    ;;
 
782
 
 
783
  default)
 
784
    action=makedefault
 
785
    shift
 
786
 
 
787
    if [ -z "$1" ] ; then
 
788
        exit_failure_syntax "application argument missing"
 
789
    fi
 
790
    case $1 in
 
791
      -*)
 
792
        exit_failure_syntax "unexpected option '$1'"
 
793
        ;;
 
794
 
 
795
      *.desktop)
 
796
        filename="$1"
 
797
        ;;
 
798
 
 
799
      *)
 
800
        exit_failure_syntax "malformed argument '$1', expected *.desktop"
 
801
        ;;
 
802
    esac
 
803
    ;;
 
804
 
 
805
  *)
 
806
  exit_failure_syntax "unknown command '$1'"
 
807
  ;;
 
808
esac
 
809
 
 
810
shift
 
811
 
 
812
 
 
813
if [ "$action" = "makedefault" ]; then
 
814
    if [ -z "$1" ] ; then
 
815
        exit_failure_syntax "mimetype argument missing"
 
816
    fi
 
817
 
 
818
    while [ $# -gt 0 ] ; do
 
819
        case $1 in
 
820
          -*)
 
821
            exit_failure_syntax "unexpected option '$1'"
 
822
            ;;
 
823
        esac
 
824
        mimetype="$1"
 
825
        shift
 
826
 
 
827
        make_default_kde "$filename" "$mimetype"
 
828
        make_default_generic "$filename" "$mimetype"
 
829
    done
 
830
    exit_success
 
831
fi
 
832
 
 
833
if [ "$action" = "info" ]; then
 
834
    detectDE
 
835
 
 
836
    if [ x"$DE" = x"" ]; then
 
837
        if [ -x /usr/bin/file ]; then
 
838
            DE=generic
 
839
        fi
 
840
    fi
 
841
 
 
842
    case "$DE" in
 
843
        kde)
 
844
        info_kde "$filename"
 
845
        ;;
 
846
 
 
847
        gnome)
 
848
        info_gnome "$filename"
 
849
        ;;
 
850
 
 
851
        *)
 
852
        info_generic "$filename"
 
853
        ;;
 
854
    esac
 
855
    exit_failure_operation_impossible "no method available for quering MIME type of '$filename'"
 
856
fi
 
857
 
 
858
if [ "$action" = "defapp" ]; then
 
859
    detectDE
 
860
 
 
861
    case "$DE" in
 
862
        kde)
 
863
        defapp_kde "$mimetype"
 
864
        ;;
 
865
 
 
866
        *)
 
867
        defapp_generic "$mimetype"
 
868
        ;;
 
869
    esac
 
870
    exit_failure_operation_impossible "no method available for quering default application for '$mimetype'"
 
871
fi
 
872
 
 
873
vendor=true
 
874
while [ $# -gt 0 ] ; do
 
875
    parm="$1"
 
876
    shift
 
877
 
 
878
    case $parm in
 
879
      --mode)
 
880
        if [ -z "$1" ] ; then
 
881
            exit_failure_syntax "mode argument missing for --mode"
 
882
        fi
 
883
        case "$1" in
 
884
          user)
 
885
            mode="user"
 
886
            ;;
 
887
 
 
888
          system)
 
889
            mode="system"
 
890
            ;;
 
891
 
 
892
          *)
 
893
            exit_failure_syntax "unknown mode '$1'"
 
894
            ;;
 
895
        esac
 
896
        shift
 
897
        ;;
 
898
 
 
899
      --novendor)
 
900
        vendor=false
 
901
        ;;
 
902
 
 
903
      -*)
 
904
        exit_failure_syntax "unexpected option '$parm'"
 
905
        ;;
 
906
 
 
907
      *)
 
908
        if [ -n "$filename" ] ; then
 
909
            exit_failure_syntax "unexpected argument '$parm'"
 
910
        fi
 
911
 
 
912
        filename="$parm"
 
913
        check_input_file "$filename"
 
914
        ;;
 
915
    esac
 
916
done
 
917
 
 
918
if [ -z "$action" ] ; then
 
919
    exit_failure_syntax "command argument missing"
 
920
fi
 
921
 
 
922
if [ -n "$XDG_UTILS_INSTALL_MODE" ] ; then
 
923
    if [ "$XDG_UTILS_INSTALL_MODE" = "system" ] ; then
 
924
        mode="system"
 
925
    elif [ "$XDG_UTILS_INSTALL_MODE" = "user" ] ; then
 
926
        mode="user"
 
927
    fi
 
928
fi
 
929
 
 
930
if [ -z "$mode" ] ; then
 
931
    if [ `whoami` = "root" ] ; then
 
932
        mode="system"
 
933
    else
 
934
        mode="user"
 
935
    fi
 
936
fi
 
937
 
 
938
if [ -z "$filename" ] ; then
 
939
    exit_failure_syntax "mimetypes-file argument missing"
 
940
fi
 
941
 
 
942
if [ "$vendor" =  "true" -a "$action" = "install" ] ; then
 
943
    check_vendor_prefix "$filename"
 
944
fi
 
945
 
 
946
xdg_base_dir=
 
947
xdg_dir_name=mime/packages/
 
948
 
 
949
xdg_user_dir="$XDG_DATA_HOME"
 
950
[ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
 
951
[ x"$mode" = x"user" ] && xdg_base_dir="$xdg_user_dir/mime"
 
952
xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
 
953
 
 
954
xdg_system_dirs="$XDG_DATA_DIRS"
 
955
[ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
 
956
for x in `echo $xdg_system_dirs | sed 's/:/ /g'`; do
 
957
    if [ -w $x/$xdg_dir_name ] ; then
 
958
        [ x"$mode" = x"system" ] && xdg_base_dir="$x/mime"
 
959
        xdg_global_dir="$x/$xdg_dir_name"
 
960
        break
 
961
    fi
 
962
done
 
963
[ -w $xdg_global_dir ] || xdg_global_dir=
 
964
DEBUG 3 "xdg_user_dir: $xdg_user_dir"
 
965
DEBUG 3 "xdg_global_dir: $xdg_global_dir"
 
966
 
 
967
# Find KDE3 mimelnk directory
 
968
kde_user_dir=
 
969
kde_global_dir=
 
970
kde_global_dirs=`kde${KDE_SESSION_VERSION}-config --path mime 2> /dev/null`
 
971
DEBUG 3 "kde_global_dirs: $kde_global_dirs"
 
972
first=
 
973
for x in `echo $kde_global_dirs | sed 's/:/ /g'` ; do
 
974
    if [ -z "$first" ] ; then
 
975
        first=false
 
976
        kde_user_dir="$x"
 
977
    elif [ -w $x ] ; then
 
978
        kde_global_dir="$x"
 
979
    fi
 
980
done
 
981
DEBUG 3 "kde_user_dir: $kde_user_dir"
 
982
DEBUG 3 "kde_global_dir: $kde_global_dir"
 
983
 
 
984
# TODO: Gnome legacy support
 
985
# See http://forums.fedoraforum.org/showthread.php?t=26875
 
986
gnome_user_dir="$HOME/.gnome/apps"
 
987
gnome_global_dir=/usr/share/gnome/apps
 
988
[ -w $gnome_global_dir ] || gnome_global_dir=
 
989
DEBUG 3 "gnome_user_dir: $gnome_user_dir"
 
990
DEBUG 3 "gnome_global_dir: $gnome_global_dir"
 
991
 
 
992
if [ x"$mode" = x"user" ] ; then
 
993
    xdg_dir="$xdg_user_dir"
 
994
    kde_dir="$kde_user_dir"
 
995
    gnome_dir="$gnome_user_dir"
 
996
    my_umask=077
 
997
else
 
998
    xdg_dir="$xdg_global_dir"
 
999
    kde_dir="$kde_global_dir"
 
1000
    gnome_dir="$gnome_global_dir"
 
1001
    my_umask=022
 
1002
    if [ -z "${xdg_dir}${kde_dir}${gnome_dir}" ] ; then
 
1003
        exit_failure_operation_impossible "No writable system mimetype directory found."
 
1004
    fi
 
1005
fi
 
1006
 
 
1007
# echo "[xdg|$xdg_user_dir|$xdg_global_dir]"
 
1008
# echo "[kde|$kde_user_dir|$kde_global_dir]"
 
1009
# echo "[gnome|$gnome_user_dir|$gnome_global_dir]"
 
1010
# echo "[using|$xdg_dir|$kde_dir|$gnome_dir]"
 
1011
 
 
1012
basefile=`basename "$filename"`
 
1013
#[ -z $vendor ] || basefile="$vendor-$basefile"
 
1014
 
 
1015
mimetypes=
 
1016
if [ -n "$kde_dir" ] ; then
 
1017
    DEBUG 2 "KDE3 mimelnk directory found, extracting mimetypes from XML file"
 
1018
 
 
1019
    mimetypes=`awk < "$filename" '
 
1020
# Strip XML comments
 
1021
BEGIN {
 
1022
 suppress=0
 
1023
}
 
1024
{
 
1025
 do
 
1026
    if (suppress) {
 
1027
       if (match($0,/-->/)) {
 
1028
           $0=substr($0,RSTART+RLENGTH)
 
1029
           suppress=0
 
1030
       }
 
1031
       else {
 
1032
           break
 
1033
       }
 
1034
    }
 
1035
    else {
 
1036
       if (match($0,/<!--/)) {
 
1037
           if (RSTART>1) print substr($0,0,RSTART)
 
1038
           $0=substr($0,RSTART+RLENGTH)
 
1039
           suppress=1
 
1040
       }
 
1041
       else {
 
1042
           if ($0) print $0
 
1043
           break
 
1044
       }
 
1045
    }
 
1046
 while(1)
 
1047
}
 
1048
' | awk '
 
1049
# List MIME types listed in <mime-type> tags
 
1050
BEGIN {
 
1051
  RS="<"
 
1052
}
 
1053
/^mime-info/, /^\/mime-info/ {
 
1054
  if (match($0,/^mime-type/)) {
 
1055
    if (match($0,/type="[^"]*/) || match($0,/type='"'"'[^'"'"']*/)) {
 
1056
      print substr($0,RSTART+6,RLENGTH-6)
 
1057
    }
 
1058
  }
 
1059
}'`
 
1060
fi
 
1061
 
 
1062
DEBUG 1 "$action mimetype in $xdg_dir"
 
1063
 
 
1064
case $action in
 
1065
    install)
 
1066
        save_umask=`umask`
 
1067
        umask $my_umask
 
1068
 
 
1069
        for x in $xdg_dir ; do
 
1070
            mkdir -p $x
 
1071
            eval 'cp $filename $x/$basefile'$xdg_redirect_output
 
1072
        done
 
1073
 
 
1074
        if [ -n "$mimetypes" ] ; then
 
1075
            # No quotes around $mimetypes
 
1076
            for x in $mimetypes ; do
 
1077
                DEBUG 1 "Installing $kde_dir/$x.desktop (KDE 3.x support)"
 
1078
                mkdir -p `dirname $kde_dir/$x.desktop`
 
1079
                awk < "$filename" '
 
1080
# Strip XML comments
 
1081
BEGIN {
 
1082
 suppress=0
 
1083
}
 
1084
{
 
1085
 do
 
1086
    if (suppress) {
 
1087
       if (match($0,/-->/)) {
 
1088
           $0=substr($0,RSTART+RLENGTH)
 
1089
           suppress=0
 
1090
       }
 
1091
       else {
 
1092
           break
 
1093
       }
 
1094
    }
 
1095
    else {
 
1096
       if (match($0,/<!--/)) {
 
1097
           if (RSTART>1) print substr($0,0,RSTART)
 
1098
           $0=substr($0,RSTART+RLENGTH)
 
1099
           suppress=1
 
1100
       }
 
1101
       else {
 
1102
           if ($0) print $0
 
1103
           break
 
1104
       }
 
1105
    }
 
1106
 while(1)
 
1107
}
 
1108
' | awk > $kde_dir/$x.desktop '
 
1109
# Extract mimetype $x from the XML file $filename
 
1110
# Note that bash requires us to escape a single quote as '"'"'
 
1111
BEGIN {
 
1112
  the_type=ARGV[1]
 
1113
  the_source=ARGV[2]
 
1114
  ARGC=1
 
1115
  RS="<"
 
1116
  found=0
 
1117
  glob_patterns=""
 
1118
}
 
1119
/^mime-info/, /^\/mime-info/ {
 
1120
  if (match($0,/^mime-type/)) {
 
1121
    if (match($0,/type="[^"]*/) || match($0,/type='"'"'[^'"'"']*/)) {
 
1122
      if (substr($0,RSTART+6,RLENGTH-6) == the_type) {
 
1123
        found=1
 
1124
        print "[Desktop Entry]"
 
1125
        print "# Installed by xdg-mime from " the_source
 
1126
        print "Type=MimeType"
 
1127
        print "MimeType=" the_type
 
1128
        the_icon=the_type
 
1129
        sub("/", "-", the_icon)
 
1130
        print "Icon=" the_icon
 
1131
      }
 
1132
    }
 
1133
  }
 
1134
  else if (found) {
 
1135
    if (match($0,/^\/mime-type/)) {
 
1136
      if (glob_patterns)
 
1137
         print "Patterns=" glob_patterns
 
1138
      exit 0
 
1139
    }
 
1140
 
 
1141
    if (match($0,/^sub-class-of/)) {
 
1142
      if (match($0,/type="[^"]*/) || match($0,/type='"'"'[^'"'"']*/)) {
 
1143
        print "X-KDE-IsAlso=" substr($0,RSTART+6,RLENGTH-6)
 
1144
      }
 
1145
      else {
 
1146
        print "Error: '"'"'type'"'"' argument missing in " RS $0
 
1147
        exit 1
 
1148
      }
 
1149
    }
 
1150
    if (match($0,/^glob/)) {
 
1151
      if (match($0,/pattern="[^"]*/) || match($0,/pattern='"'"'[^'"'"']*/)) {
 
1152
        glob_patterns = glob_patterns substr($0,RSTART+9,RLENGTH-9) ";"
 
1153
      }
 
1154
      else {
 
1155
        print "Error: '"'"'pattern'"'"' argument missing in " RS $0
 
1156
        exit 1
 
1157
      }
 
1158
    }
 
1159
    if (match($0,/^comment/)) {
 
1160
      if (match($0,/xml:lang="[^"]*/) || match($0,/xml:lang='"'"'[^'"'"']*/)) {
 
1161
        lang=substr($0,RSTART+10,RLENGTH-10)
 
1162
      }
 
1163
      else {
 
1164
        lang=""
 
1165
      }
 
1166
      if (match($0,/>/)) {
 
1167
        comment=substr($0,RSTART+1)
 
1168
        sub("&lt;", "<", comment)
 
1169
        sub("&gt;", ">", comment)
 
1170
        sub("&amp;", "\\&", comment)
 
1171
        if (lang)
 
1172
           print "Comment[" lang "]=" comment
 
1173
        else
 
1174
           print "Comment=" comment
 
1175
      }
 
1176
    }
 
1177
  }
 
1178
}
 
1179
END {
 
1180
  if (!found) {
 
1181
    print "Error: Mimetype '"'"'" the_type "'"'"' not found"
 
1182
    exit 1
 
1183
  }
 
1184
}
 
1185
' $x $basefile
 
1186
                if [ "$?" = "1" ] ; then
 
1187
                    grep -A 10 "^Error:" $kde_dir/$x.desktop >&2
 
1188
                    rm $kde_dir/$x.desktop
 
1189
                    exit 1
 
1190
                fi
 
1191
            done
 
1192
        fi
 
1193
 
 
1194
        umask $save_umask
 
1195
        ;;
 
1196
 
 
1197
    uninstall)
 
1198
        for x in $xdg_dir ; do
 
1199
            rm -f $x/$basefile
 
1200
        done
 
1201
 
 
1202
        # No quotes around $mimetypes
 
1203
        for x in $mimetypes ; do
 
1204
            if grep '^# Installed by xdg-mime' $kde_dir/$x.desktop >/dev/null 2>&1; then
 
1205
                DEBUG 1 "Removing $kde_dir/$x.desktop (KDE 3.x support)"
 
1206
                rm -f $kde_dir/$x.desktop
 
1207
            fi
 
1208
        done
 
1209
        ;;
 
1210
esac
 
1211
 
 
1212
update_mime_database $xdg_base_dir
 
1213
 
 
1214
exit_success
 
1215