Changeset 125662


Ignore:
Timestamp:
Sep 23, 2014, 8:56:51 PM (6 years ago)
Author:
devans@…
Message:

GNOME-3/stable: update initial ports to GNOME stable release 3.14 versions for testing.

  • devel/glib2 2.42.0
  • devel/glibmm 2.42.0
  • devel/libsigcxx2 2.4.0
  • gnome/adwaita-icon-theme 3.14.0
  • gnome/at-spi2-atk 2.14.0
  • gnome/at-spi2-core 2.14.0
  • gnome/dconf 0.22.0
  • gnome/glib-networking 2.42.0
  • gnome/gnome-backgrounds 3.14.0
  • gnome/gnome-common 3.14.0
  • gnome/gnome-desktop 3.14.0
  • gnome/gnome-themes-standard 3.14.0
  • gnome/gsettings-desktop-schemas 3.14.0
  • gnome/gtk3 3.14.0
  • gnome/libgdata 0.16.0
  • gnome/libsoup 2.48.0
  • lang/vala 0.26.0
  • python/py-gobject3 3.14.0
  • x11/gtkmm3 3.14.0
Location:
users/devans/GNOME-3/stable/dports
Files:
1 deleted
35 edited
6 copied

Legend:

Unmodified
Added
Removed
  • users/devans/GNOME-3/stable/dports/devel/glib2

  • users/devans/GNOME-3/stable/dports/devel/glib2/Portfile

    r120169 r125662  
    1111conflicts                   glib2-devel
    1212set my_name                 glib
    13 version                     2.40.0
    14 revision                    1
     13version                     2.42.0
    1514set branch                  [join [lrange [split ${version} .] 0 1] .]
    1615categories                  devel
     
    3332                            ftp://ftp.gtk.org/pub/${my_name}/${branch}/
    3433
    35 checksums                   rmd160  c50eed34bf8df127b959af27b02d6036934f758e \
    36                             sha256  0d27f195966ecb1995dcce0754129fd66ebe820c7cd29200d264b02af1aa28b5
     34checksums                   rmd160  3d2434ee1d1e68d39ddb27cbfee025fcb4e0197e \
     35                            sha256  94fbc0a7d10633433ff383e540607de649c1b46baaa59dea446a50977a6c4472
    3736
    3837# ${prefix}/include/glib-2.0/glib/gi18n.h requires -I${prefix}/include to find libintl.h
     
    8483    reinplace "s|#! */usr/bin/env python|#!${configure.python}|g" ${worksrcpath}/glib/gtester-report
    8584    reinplace "s|-Werror=missing-prototypes||" ${worksrcpath}/configure
    86 
    87     # https://bugzilla.gnome.org/show_bug.cgi?id=700350
    88     touch ${worksrcpath}/docs/reference/glib/Makefile.in \
    89           ${worksrcpath}/docs/reference/gobject/Makefile.in \
    90           ${worksrcpath}/docs/reference/gio/Makefile.in \
    91           ${worksrcpath}/docs/reference/gio/gdbus-object-manager-example/Makefile.in
    9285}
    9386
  • users/devans/GNOME-3/stable/dports/devel/glib2/files/patch-glib-2.0.pc.in.diff

    r91680 r125662  
    1 --- glib-2.0.pc.in.orig 2012-01-15 21:12:06.000000000 -0600
    2 +++ glib-2.0.pc.in      2012-01-19 22:29:43.000000000 -0600
     1--- glib-2.0.pc.in.orig 2014-04-07 08:01:32.000000000 -0500
     2+++ glib-2.0.pc.in      2014-05-27 20:44:09.000000000 -0500
    33@@ -13,4 +13,4 @@
    44 Requires.private: @PCRE_REQUIRES@
    55 Libs: -L${libdir} -lglib-2.0 @INTLLIBS@
    6  Libs.private: @G_THREAD_LIBS@ @G_LIBS_EXTRA@ @PCRE_LIBS@ @INTLLIBS@ @ICONV_LIBS@
     6 Libs.private: @G_THREAD_LIBS@ @G_LIBS_EXTRA@ @PCRE_LIBS@ @INTLLIBS@ @ICONV_LIBS@ @CARBON_LIBS@ @COCOA_LIBS@
    77-Cflags: -I${includedir}/glib-2.0 -I${libdir}/glib-2.0/include @GLIB_EXTRA_CFLAGS@
    88+Cflags: -I${includedir}/glib-2.0 -I${libdir}/glib-2.0/include -I${includedir} @GLIB_EXTRA_CFLAGS@
  • users/devans/GNOME-3/stable/dports/devel/glibmm

  • users/devans/GNOME-3/stable/dports/devel/glibmm/Portfile

    r119139 r125662  
    55
    66name            glibmm
    7 version         2.40.0
     7version         2.42.0
    88set branch      [join [lrange [split ${version} .] 0 1] .]
    99description     C++ interface to glib
     
    1919use_xz          yes
    2020
    21 checksums       rmd160  4d367eb37bfa1f24ee8621f0d25993b46e5f5a31 \
    22                 sha256  34f320fad7e0057c63863706caa802ae0051b21523bed91ec33baf8421ca484f
     21checksums       rmd160  f859f463fd4acce435a62f9c69b9560087787754 \
     22                sha256  985083d97378d234da27a7243587cc0d186897a4b2d3c1286f794089be1a3397
    2323
    2424depends_build   port:pkgconfig \
  • users/devans/GNOME-3/stable/dports/devel/libsigcxx2

  • users/devans/GNOME-3/stable/dports/devel/libsigcxx2/Portfile

    r125561 r125662  
    1111categories      devel
    1212platforms       darwin
    13 maintainers     nomaintainer
     13maintainers     devans openmaintainer
    1414description     C++ signal callback system
    1515
  • users/devans/GNOME-3/stable/dports/gnome/adwaita-icon-theme/Portfile

    r125521 r125662  
    55
    66name                adwaita-icon-theme
    7 version             3.13.91
     7version             3.14.0
    88set branch          [join [lrange [split ${version} .] 0 1] .]
    99categories          gnome
     
    2121use_xz              yes
    2222
    23 checksums           rmd160  ab261ecc3e9600253d9973d60d2a9b1675a21840 \
    24                     sha256  d0cf4705d3439c68d344431b62cca5fe6fcf91bd38c745c48b2476d0aa41b8ad
     23checksums           rmd160  4eed31c91347692089d5d35239ffb0af2a9a9412 \
     24                    sha256  afacb6025a18be007e33a9663b92cee9d2745279bb00107a68e09b2806f9541f
    2525
    2626depends_build       port:pkgconfig \
     
    6565"
    6666
    67 livecheck.type      gnome-with-unstable
     67livecheck.type      gnome
  • users/devans/GNOME-3/stable/dports/gnome/at-spi2-atk/Portfile

    r122321 r125662  
    66name                at-spi2-atk
    77# you probably want to keep this at the same version as at-spi2-core
    8 version             2.13.4
    9 checksums           rmd160  f9ad7db8c8ef360bfc2ee5622adc5b36fd9db4a9 \
    10                     sha256  b20ede423cdf95ae34feca08b1f01afccafd75c37a3c8060b04beed31b18af15
     8version             2.14.0
     9checksums           rmd160  32ae861325849f140d380b157e8c2e8b611b51cc \
     10                    sha256  56b40ef16d9f1b1630d32addb0cc941372a1e97d8ddafd369f912c7d125688e7
    1111
    1212license             LGPL
     
    3939autoreconf.args     -fvi
    4040
    41 livecheck.type      gnome-with-unstable
     41livecheck.type      gnome
  • users/devans/GNOME-3/stable/dports/gnome/at-spi2-core

  • users/devans/GNOME-3/stable/dports/gnome/at-spi2-core/Portfile

    r119883 r125662  
    66name                at-spi2-core
    77# you probably want to keep this at the same version as at-spi2-atk
    8 version             2.12.0
    9 checksums           rmd160  33444c2f8902990b20225bf7588b09ae80ed9e7d \
    10                     sha256  db550edd98e53b4252521459c2dcaf0f3b060a9bad52489b9dbadbaedad3fb89
     8version             2.14.0
     9checksums           rmd160  919f4fd1ae5cee9121232a7f01ee44f6046437b9 \
     10                    sha256  5807b02e6ef695b52fde7ff26d675dd94a0707df3c42fe7fd224828e092514c8
    1111
    1212license             LGPL
     
    6161build.env-append    CC=${configure.cc}
    6262
    63 livecheck.type      gnome
     63livecheck.type      gnome-with-unstable
  • users/devans/GNOME-3/stable/dports/gnome/dconf

  • users/devans/GNOME-3/stable/dports/gnome/dconf/Portfile

    r118246 r125662  
    55
    66name            dconf
    7 version         0.20.0
     7version         0.22.0
    88set branch      [join [lrange [split ${version} .] 0 1] .]
    99maintainers     devans openmaintainer
     
    2424use_xz          yes
    2525
    26 checksums       rmd160  eae9e6cbe6c41e76225933239672dd794c168b80 \
    27                 sha256  22c046a247d05ea65ad181e3aef4009c898a5531f76c0181f8ec0dfef83447d9
     26checksums       rmd160  a69abcb409ebdb3a72923ecbb23cbf5b43a5f98c \
     27                sha256  0a277cb0c3f09e77d9413c5a9b3577fc2b5d6e941b59b44940392e024a224b8e
    2828
    2929depends_build   port:pkgconfig \
     
    6060}
    6161
    62 livecheck.type  gnome
     62livecheck.type  gnome-with-unstable
  • users/devans/GNOME-3/stable/dports/gnome/glib-networking

  • users/devans/GNOME-3/stable/dports/gnome/glib-networking/Portfile

    r120602 r125662  
    55
    66name            glib-networking
    7 version         2.40.1
    8 revision        1
     7version         2.42.0
    98set branch      [join [lrange [split ${version} .] 0 1] .]
    109description     Network-related giomodules for glib
     
    1918use_xz          yes
    2019
    21 checksums       rmd160  37db7fc553224e17518c241bfb375d8b44ede365 \
    22                 sha256  9fb3e54d049a480afdb814ff7452e7ab67e5d5f607ade230d7713f19922b5a28
     20checksums       rmd160  e64574a1f16eafcebf2351c8b1a55879ccbe162e \
     21                sha256  304dd9e4c0ced69094300e0b9e66cd2eaae7161b9fc3186536d11458677d820d
    2322
    2423depends_build   port:pkgconfig \
  • users/devans/GNOME-3/stable/dports/gnome/gnome-backgrounds

  • users/devans/GNOME-3/stable/dports/gnome/gnome-backgrounds/Portfile

    r119990 r125662  
    55
    66name                gnome-backgrounds
    7 version             3.12.2
     7version             3.14.0
    88set branch          [join [lrange [split ${version} .] 0 1] .]
    99maintainers         nomaintainer
     
    2222use_xz              yes
    2323
    24 checksums           rmd160  e20c2d582c664752dc44a1f07e109d9ebd4f9bb0 \
    25                     sha256  ac4d3e0fffc5991865ca748e728a1ab87f167400105250ce2195b03502427180
     24checksums           rmd160  a0365885acf9861ab36994d71a6e473bfdc75b17 \
     25                    sha256  1a713bb2a0d717ee03dc296d450f51bc8124099d3f8b82d497078f2163684c7c
    2626
    2727depends_build       port:intltool \
  • users/devans/GNOME-3/stable/dports/gnome/gnome-common/Portfile

    r118192 r125662  
    55
    66name            gnome-common
    7 version         3.12.0
     7version         3.14.0
    88set branch      [join [lrange [split ${version} .] 0 1] .]
    99maintainers     nomaintainer
     
    2424use_xz          yes
    2525
    26 checksums       rmd160  f23cb20600b9dd15da3149f9f585d2ceb69a531c \
    27                 sha256  18712bc2df6b2dd88a11b9f7f874096d1c0c6e7ebc9cfc0686ef963bd590e1d8
     26checksums       rmd160  4ce69a5bb5c428b4aadc155e0bae51a04e897cad \
     27                sha256  4c00242f781bb441289f49dd80ed1d895d84de0c94bfc2c6818a104c9e39262c
    2828
    2929patchfiles      patch-gnome-autogen.sh.diff
  • users/devans/GNOME-3/stable/dports/gnome/gnome-desktop

  • users/devans/GNOME-3/stable/dports/gnome/gnome-desktop/Portfile

    r120017 r125662  
    55
    66name            gnome-desktop
    7 version         3.12.2
     7version         3.14.0
    88set branch      [join [lrange [split ${version} .] 0 1] .]
    99maintainers     devans openmaintainer
     
    2525use_xz          yes
    2626
    27 checksums       rmd160  9f801d21dec8b84d467e5a13206f568efd824210 \
    28                 sha256  b7d691363ccc90182caff1980efa7d99e4569bea968d39654102a0c4e824a44d
     27checksums       rmd160  178de1265e9afd081fb32f2696f6eb7bd139114f \
     28                sha256  22ced99396c022b5a8f2d78cdf7ff6227939c4ed36bc5dd806d44735d7b98305
    2929
    3030depends_build   port:pkgconfig \
     
    3636                port:gsettings-desktop-schemas \
    3737                path:share/themes/HighContrast/index.theme:gnome-themes-standard \
     38                port:adwaita-icon-theme \
    3839                port:gtk3 \
    3940                port:gobject-introspection \
     
    4445                port:xorg-libxkbfile
    4546
    46 patchfiles      patch-gnome-desktop-Makefile.am.diff \
    47                 patch-libgnome-destktop-libgsystem.diff
     47patchfiles      patch-libgnome-destktop-libgsystem.diff
    4848
    4949# update m4/intltool.m4 and autoreconf
  • users/devans/GNOME-3/stable/dports/gnome/gnome-desktop/files/patch-libgnome-destktop-libgsystem.diff

    r118155 r125662  
    5454 }
    5555 
    56 diff -urN libgnome-desktop/libgsystem.orig/gsystem-file-utils.c.orig libgnome-desktop/libgsystem/gsystem-file-utils.c.orig
    57 --- libgnome-desktop/libgsystem.orig/gsystem-file-utils.c.orig  1969-12-31 16:00:00.000000000 -0800
    58 +++ libgnome-desktop/libgsystem/gsystem-file-utils.c.orig       2014-01-15 13:06:25.000000000 -0800
    59 @@ -0,0 +1,1626 @@
    60 +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
    61 + *
    62 + * Copyright (C) 2012 William Jon McCann <mccann@redhat.com>
    63 + * Copyright (C) 2012 Colin Walters <walters@verbum.org>
    64 + *
    65 + * This library is free software; you can redistribute it and/or
    66 + * modify it under the terms of the GNU Lesser General Public
    67 + * License as published by the Free Software Foundation; either
    68 + * version 2 of the License, or (at your option) any later version.
    69 + *
    70 + * This library is distributed in the hope that it will be useful,
    71 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    72 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    73 + * Lesser General Public License for more details.
    74 + *
    75 + * You should have received a copy of the GNU Lesser General Public
    76 + * License along with this library; if not, write to the
    77 + * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    78 + * Boston, MA 02111-1307, USA.
    79 + */
    80 +
    81 +#include "config.h"
    82 +
    83 +#ifndef _GNU_SOURCE
    84 +#define _GNU_SOURCE
    85 +#endif
    86 +
    87 +#include <string.h>
    88 +
    89 +#define _GSYSTEM_NO_LOCAL_ALLOC
    90 +#include "libgsystem.h"
    91 +#include "gsystem-glib-compat.h"
    92 +#include <glib/gstdio.h>
    93 +#include <gio/gunixinputstream.h>
    94 +#include <gio/gfiledescriptorbased.h>
    95 +#include <gio/gunixoutputstream.h>
    96 +#include <glib-unix.h>
    97 +#include <limits.h>
    98 +#include <dirent.h>
    99 +#ifdef GSYSTEM_CONFIG_XATTRS
    100 +#include <attr/xattr.h>
    101 +#endif
    102 +
    103 +static int
    104 +close_nointr (int fd)
    105 +{
    106 +  int res;
    107 +  /* Note this is NOT actually a retry loop.
    108 +   * See: https://bugzilla.gnome.org/show_bug.cgi?id=682819
    109 +   */
    110 +  res = close (fd);
    111 +  /* Just ignore EINTR...on Linux, retrying is wrong. */
    112 +  if (res == EINTR)
    113 +    res = 0;
    114 +  return res;
    115 +}
    116 +
    117 +static void
    118 +close_nointr_noerror (int fd)
    119 +{
    120 +  (void) close_nointr (fd);
    121 +}
    122 +
    123 +static int
    124 +open_nointr (const char *path, int flags, mode_t mode)
    125 +{
    126 +  int res;
    127 +  do
    128 +    res = open (path, flags, mode);
    129 +  while (G_UNLIKELY (res == -1 && errno == EINTR));
    130 +  return res;
    131 +}
    132 +
    133 +static inline void
    134 +_set_error_from_errno (GError **error)
    135 +{
    136 +  int errsv = errno;
    137 +  g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    138 +                       g_strerror (errsv));
    139 +}
    140 +
    141 +/**
    142 + * gs_file_openat_noatime:
    143 + * @dfd: File descriptor for directory
    144 + * @name: Pathname, relative to @dfd
    145 + * @ret_fd: (out): Returned file descriptor
    146 + * @cancellable: Cancellable
    147 + * @error: Error
    148 + *
    149 + * Wrapper for openat() using %O_RDONLY with %O_NOATIME if available.
    150 + */
    151 +gboolean
    152 +gs_file_openat_noatime (int            dfd,
    153 +                        const char    *name,
    154 +                        int           *ret_fd,
    155 +                        GCancellable  *cancellable,
    156 +                        GError       **error)
    157 +{
    158 +  int fd;
    159 +
    160 +#ifdef O_NOATIME
    161 +  do
    162 +    fd = openat (dfd, name, O_RDONLY | O_NOATIME, 0);
    163 +  while (G_UNLIKELY (fd == -1 && errno == EINTR));
    164 +  /* Only the owner or superuser may use O_NOATIME; so we may get
    165 +   * EPERM.  EINVAL may happen if the kernel is really old...
    166 +   */
    167 +  if (fd == -1 && (errno == EPERM || errno == EINVAL))
    168 +#endif
    169 +    do
    170 +      fd = openat (dfd, name, O_RDONLY, 0);
    171 +    while (G_UNLIKELY (fd == -1 && errno == EINTR));
    172 
    173 +  if (fd == -1)
    174 +    {
    175 +      _set_error_from_errno (error);
    176 +      return FALSE;
    177 +    }
    178 +  else
    179 +    {
    180 +      *ret_fd = fd;
    181 +      return TRUE;
    182 +    }
    183 +}
    184 +
    185 +/**
    186 + * gs_file_read_noatime:
    187 + * @file: a #GFile
    188 + * @cancellable: a #GCancellable
    189 + * @error: a #GError
    190 + *
    191 + * Like g_file_read(), but try to avoid updating the file's
    192 + * access time.  This should be used by background scanning
    193 + * components such as search indexers, antivirus programs, etc.
    194 + *
    195 + * Returns: (transfer full): A new input stream, or %NULL on error
    196 + */
    197 +GInputStream *
    198 +gs_file_read_noatime (GFile         *file,
    199 +                      GCancellable  *cancellable,
    200 +                      GError       **error)
    201 +{
    202 +  const char *path = NULL;
    203 +  int fd;
    204 +
    205 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    206 +    return NULL;
    207 +
    208 +  path = gs_file_get_path_cached (file);
    209 +  if (path == NULL)
    210 +    {
    211 +      char *uri;
    212 +      uri = g_file_get_uri (file);
    213 +      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_NOENT,
    214 +                   "%s has no associated path", uri);
    215 +      g_free (uri);
    216 +      return NULL;
    217 +    }
    218 +
    219 +  if (!gs_file_openat_noatime (AT_FDCWD, path, &fd, cancellable, error))
    220 +    return NULL;
    221 +
    222 +  return g_unix_input_stream_new (fd, TRUE);
    223 +}
    224 +
    225 +/**
    226 + * gs_stream_fstat:
    227 + * @stream: A stream containing a Unix file descriptor
    228 + * @stbuf: Memory location to write stat buffer
    229 + * @cancellable:
    230 + * @error:
    231 + *
    232 + * Some streams created via libgsystem are #GUnixInputStream; these do
    233 + * not support e.g. g_file_input_stream_query_info().  This function
    234 + * allows dropping to the raw unix fstat() call for these types of
    235 + * streams, while still conveniently wrapped with the normal GLib
    236 + * handling of @cancellable and @error.
    237 + */
    238 +gboolean
    239 +gs_stream_fstat (GFileDescriptorBased *stream,
    240 +                 struct stat          *stbuf,
    241 +                 GCancellable         *cancellable,
    242 +                 GError              **error)
    243 +{
    244 +  gboolean ret = FALSE;
    245 +  int fd;
    246 +
    247 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    248 +    goto out;
    249 +
    250 +  fd = g_file_descriptor_based_get_fd (stream);
    251 +
    252 +  if (fstat (fd, stbuf) == -1)
    253 +    {
    254 +      _set_error_from_errno (error);
    255 +      goto out;
    256 +    }
    257 +
    258 +  ret = TRUE;
    259 + out:
    260 +  return ret;
    261 +}
    262 +
    263 +/**
    264 + * gs_file_map_noatime: (skip)
    265 + * @file: a #GFile
    266 + * @cancellable: a #GCancellable
    267 + * @error: a #GError
    268 + *
    269 + * Like g_mapped_file_new(), but try to avoid updating the file's
    270 + * access time.  This should be used by background scanning
    271 + * components such as search indexers, antivirus programs, etc.
    272 + *
    273 + * Returns: (transfer full): A new mapped file, or %NULL on error
    274 + */
    275 +GMappedFile *
    276 +gs_file_map_noatime (GFile         *file,
    277 +                     GCancellable  *cancellable,
    278 +                     GError       **error)
    279 +{
    280 +  const char *path;
    281 +  int fd;
    282 +  GMappedFile *ret;
    283 +
    284 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    285 +    return NULL;
    286 +
    287 +  path = gs_file_get_path_cached (file);
    288 +  if (path == NULL)
    289 +    return NULL;
    290 +
    291 +  if (!gs_file_openat_noatime (AT_FDCWD, path, &fd, cancellable, error))
    292 +    return NULL;
    293 
    294 +  ret = g_mapped_file_new_from_fd (fd, FALSE, error);
    295 +  close_nointr_noerror (fd); /* Ignore errors - we always want to close */
    296 +
    297 +  return ret;
    298 +}
    299 +
    300 +#if GLIB_CHECK_VERSION(2,34,0)
    301 +/**
    302 + * gs_file_map_readonly:
    303 + * @file: a #GFile
    304 + * @cancellable:
    305 + * @error:
    306 + *
    307 + * Return a #GBytes which references a readonly view of the contents of
    308 + * @file.  This function uses #GMappedFile internally.
    309 + *
    310 + * Returns: (transfer full): a newly referenced #GBytes
    311 + */
    312 +GBytes *
    313 +gs_file_map_readonly (GFile         *file,
    314 +                      GCancellable  *cancellable,
    315 +                      GError       **error)
    316 +{
    317 +  GMappedFile *mfile;
    318 +  GBytes *ret;
    319 +
    320 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    321 +    return NULL;
    322 +
    323 +  mfile = g_mapped_file_new (gs_file_get_path_cached (file), FALSE, error);
    324 +  if (!mfile)
    325 +    return NULL;
    326 +
    327 +  ret = g_mapped_file_get_bytes (mfile);
    328 +  g_mapped_file_unref (mfile);
    329 +  return ret;
    330 +}
    331 +#endif
    332 +
    333 +/**
    334 + * gs_file_sync_data:
    335 + * @file: a #GFile
    336 + * @cancellable:
    337 + * @error:
    338 + *
    339 + * Wraps the UNIX fsync() function (or fdatasync(), if available), which
    340 + * ensures that the data in @file is on non-volatile storage.
    341 + */
    342 +gboolean
    343 +gs_file_sync_data (GFile          *file,
    344 +                   GCancellable   *cancellable,
    345 +                   GError        **error)
    346 +{
    347 +  gboolean ret = FALSE;
    348 +  int res;
    349 +  int fd = -1;
    350 +
    351 +  if (!gs_file_openat_noatime (AT_FDCWD, gs_file_get_path_cached (file), &fd,
    352 +                               cancellable, error))
    353 +    goto out;
    354 +
    355 +  do
    356 +    {
    357 +#ifdef __linux
    358 +      res = fdatasync (fd);
    359 +#else
    360 +      res = fsync (fd);
    361 +#endif
    362 +    }
    363 +  while (G_UNLIKELY (res != 0 && errno == EINTR));
    364 +  if (res != 0)
    365 +    {
    366 +      _set_error_from_errno (error);
    367 +      goto out;
    368 +    }
    369 +
    370 +  res = close_nointr (fd);
    371 +  if (res != 0)
    372 +    {
    373 +      _set_error_from_errno (error);
    374 +      goto out;
    375 +    }
    376 +  fd = -1;
    377 
    378 +  ret = TRUE;
    379 + out:
    380 +  if (fd != -1)
    381 +    close_nointr_noerror (fd);
    382 +  return ret;
    383 +}
    384 +
    385 +/**
    386 + * gs_file_create:
    387 + * @file: Path to non-existent file
    388 + * @mode: Unix access permissions
    389 + * @out_stream: (out) (transfer full) (allow-none): Newly created output, or %NULL
    390 + * @cancellable: a #GCancellable
    391 + * @error: a #GError
    392 + *
    393 + * Like g_file_create(), except this function allows specifying the
    394 + * access mode.  This allows atomically creating private files.
    395 + */
    396 +gboolean
    397 +gs_file_create (GFile          *file,
    398 +                int             mode,
    399 +                GOutputStream **out_stream,
    400 +                GCancellable   *cancellable,
    401 +                GError        **error)
    402 +{
    403 +  gboolean ret = FALSE;
    404 +  int fd;
    405 +  GOutputStream *ret_stream = NULL;
    406 +
    407 +  fd = open_nointr (gs_file_get_path_cached (file), O_WRONLY | O_CREAT | O_EXCL, mode);
    408 +  if (fd < 0)
    409 +    {
    410 +      _set_error_from_errno (error);
    411 +      goto out;
    412 +    }
    413 +
    414 +  if (fchmod (fd, mode) < 0)
    415 +    {
    416 +      close (fd);
    417 +      _set_error_from_errno (error);
    418 +      goto out;
    419 +    }
    420 
    421 +  ret_stream = g_unix_output_stream_new (fd, TRUE);
    422 
    423 +  ret = TRUE;
    424 +  gs_transfer_out_value (out_stream, &ret_stream);
    425 + out:
    426 +  g_clear_object (&ret_stream);
    427 +  return ret;
    428 +}
    429 +
    430 +static const char *
    431 +get_default_tmp_prefix (void)
    432 +{
    433 +  static char *tmpprefix = NULL;
    434 +
    435 +  if (g_once_init_enter (&tmpprefix))
    436 +    {
    437 +      const char *prgname = g_get_prgname ();
    438 +      const char *p;
    439 +      char *prefix;
    440 +      char *iter;
    441 +
    442 +      if (prgname)
    443 +        {
    444 +          p = strrchr (prgname, '/');
    445 +          if (p)
    446 +            prgname = p + 1;
    447 +        }
    448 +      else
    449 +        prgname = "";
    450 +         
    451 +      prefix = g_strdup_printf ("tmp-%s%u-", prgname, getuid ());
    452 +      for (iter = prefix; *iter; iter++)
    453 +        {
    454 +          char c = *iter;
    455 +          if (c == ' ')
    456 +            *iter = '_';
    457 +        }
    458 +     
    459 +      g_once_init_leave (&tmpprefix, prefix);
    460 +    }
    461 +
    462 +  return tmpprefix;
    463 +}
    464 +
    465 +/**
    466 + * gs_fileutil_gen_tmp_name:
    467 + * @prefix: (allow-none): String prepended to the result
    468 + * @suffix: (allow-none): String suffixed to the result
    469 + *
    470 + * Generate a name suitable for use as a temporary file.  This
    471 + * function does no I/O; it is not guaranteed that a file with that
    472 + * name does not exist.
    473 + */
    474 +char *
    475 +gs_fileutil_gen_tmp_name (const char *prefix,
    476 +                          const char *suffix)
    477 +{
    478 +  static const char table[] = "ABCEDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789";
    479 +  GString *str = g_string_new ("");
    480 +  guint i;
    481 +
    482 +  if (!prefix)
    483 +    prefix = get_default_tmp_prefix ();
    484 +  if (!suffix)
    485 +    suffix = "tmp";
    486 +
    487 +  g_string_append (str, prefix);
    488 +  for (i = 0; i < 8; i++)
    489 +    {
    490 +      int offset = g_random_int_range (0, sizeof (table) - 1);
    491 +      g_string_append_c (str, (guint8)table[offset]);
    492 +    }
    493 +  g_string_append_c (str, '.');
    494 +  g_string_append (str, suffix);
    495 +
    496 +  return g_string_free (str, FALSE);
    497 +}
    498 +
    499 +/**
    500 + * gs_file_open_dir_fd:
    501 + * @path: Directory name
    502 + * @out_fd: (out): File descriptor for directory
    503 + * @cancellable: Cancellable
    504 + * @error: Error
    505 + *
    506 + * On success, sets @out_fd to a file descriptor for the directory
    507 + * that can be used with UNIX functions such as openat().
    508 + */
    509 +gboolean
    510 +gs_file_open_dir_fd (GFile         *path,
    511 +                     int           *out_fd,
    512 +                     GCancellable  *cancellable,
    513 +                     GError       **error)
    514 +{
    515 +  /* Linux specific probably */
    516 +  *out_fd = open (gs_file_get_path_cached (path), O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC);
    517 +  if (*out_fd == -1)
    518 +    {
    519 +      _set_error_from_errno (error);
    520 +      return FALSE;
    521 +    }
    522 +  return TRUE;
    523 +}
    524 +
    525 +/**
    526 + * gs_file_open_in_tmpdir_at:
    527 + * @tmpdir_fd: Directory to place temporary file
    528 + * @mode: Default mode (will be affected by umask)
    529 + * @out_name: (out) (transfer full): Newly created file name
    530 + * @out_stream: (out) (transfer full) (allow-none): Newly created output stream
    531 + * @cancellable:
    532 + * @error:
    533 + *
    534 + * Like g_file_open_tmp(), except the file will be created in the
    535 + * provided @tmpdir, and allows specification of the Unix @mode, which
    536 + * means private files may be created.  Return values will be stored
    537 + * in @out_name, and optionally @out_stream.
    538 + */
    539 +gboolean
    540 +gs_file_open_in_tmpdir_at (int                tmpdir_fd,
    541 +                           int                mode,
    542 +                           char             **out_name,
    543 +                           GOutputStream    **out_stream,
    544 +                           GCancellable      *cancellable,
    545 +                           GError           **error)
    546 +{
    547 +  gboolean ret = FALSE;
    548 +  const int max_attempts = 128;
    549 +  int i;
    550 +  char *tmp_name = NULL;
    551 +  int fd;
    552 +
    553 +  /* 128 attempts seems reasonable... */
    554 +  for (i = 0; i < max_attempts; i++)
    555 +    {
    556 +      g_free (tmp_name);
    557 +      tmp_name = gs_fileutil_gen_tmp_name (NULL, NULL);
    558 +
    559 +      do
    560 +        fd = openat (tmpdir_fd, tmp_name, O_WRONLY | O_CREAT | O_EXCL, mode);
    561 +      while (fd == -1 && errno == EINTR);
    562 +      if (fd < 0 && errno != EEXIST)
    563 +        {
    564 +          _set_error_from_errno (error);
    565 +          goto out;
    566 +        }
    567 +      else if (fd != -1)
    568 +        break;
    569 +    }
    570 +  if (i == max_attempts)
    571 +    {
    572 +      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
    573 +                   "Exhausted attempts to open temporary file");
    574 +      goto out;
    575 +    }
    576 +
    577 +  ret = TRUE;
    578 +  gs_transfer_out_value (out_name, &tmp_name);
    579 +  if (out_stream)
    580 +    *out_stream = g_unix_output_stream_new (fd, TRUE);
    581 +  else
    582 +    (void) close (fd);
    583 + out:
    584 +  g_free (tmp_name);
    585 +  return ret;
    586 +}
    587 +
    588 +/**
    589 + * gs_file_open_in_tmpdir:
    590 + * @tmpdir: Directory to place temporary file
    591 + * @mode: Default mode (will be affected by umask)
    592 + * @out_file: (out) (transfer full): Newly created file path
    593 + * @out_stream: (out) (transfer full) (allow-none): Newly created output stream
    594 + * @cancellable:
    595 + * @error:
    596 + *
    597 + * Like g_file_open_tmp(), except the file will be created in the
    598 + * provided @tmpdir, and allows specification of the Unix @mode, which
    599 + * means private files may be created.  Return values will be stored
    600 + * in @out_file, and optionally @out_stream.
    601 + */
    602 +gboolean
    603 +gs_file_open_in_tmpdir (GFile             *tmpdir,
    604 +                        int                mode,
    605 +                        GFile            **out_file,
    606 +                        GOutputStream    **out_stream,
    607 +                        GCancellable      *cancellable,
    608 +                        GError           **error)
    609 +{
    610 +  gboolean ret = FALSE;
    611 +  DIR *d = NULL;
    612 +  int dfd = -1;
    613 +  char *tmp_name = NULL;
    614 +  GOutputStream *ret_stream = NULL;
    615 +
    616 +  d = opendir (gs_file_get_path_cached (tmpdir));
    617 +  if (!d)
    618 +    {
    619 +      _set_error_from_errno (error);
    620 +      goto out;
    621 +    }
    622 +  dfd = dirfd (d);
    623 +
    624 +  if (!gs_file_open_in_tmpdir_at (dfd, mode, &tmp_name,
    625 +                                  out_stream ? &ret_stream : NULL,
    626 +                                  cancellable, error))
    627 +    goto out;
    628 +
    629 +  ret = TRUE;
    630 +  *out_file = g_file_get_child (tmpdir, tmp_name);
    631 +  gs_transfer_out_value (out_stream, &ret_stream);
    632 + out:
    633 +  if (d) (void) closedir (d);
    634 +  g_clear_object (&ret_stream);
    635 +  g_free (tmp_name);
    636 +  return ret;
    637 +}
    638 +
    639 +static gboolean
    640 +linkcopy_internal_attempt (GFile          *src,
    641 +                          GFile          *dest,
    642 +                          GFile          *dest_parent,
    643 +                          GFileCopyFlags  flags,
    644 +                          gboolean        sync_data,
    645 +                          gboolean        enable_guestfs_fuse_workaround,
    646 +                          gboolean       *out_try_again,
    647 +                          GCancellable   *cancellable,
    648 +                          GError        **error)
    649 +{
    650 +  gboolean ret = FALSE;
    651 +  int res;
    652 +  char *tmp_name = NULL;
    653 +  GFile *tmp_dest = NULL;
    654 +
    655 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    656 +    goto out;
    657 +
    658 +  tmp_name = gs_fileutil_gen_tmp_name (NULL, NULL);
    659 +  tmp_dest = g_file_get_child (dest_parent, tmp_name);
    660 +
    661 +  res = link (gs_file_get_path_cached (src), gs_file_get_path_cached (tmp_dest));
    662 +  if (res == -1)
    663 +    {
    664 +      if (errno == EEXIST)
    665 +        {
    666 +          /* Nothing, fall through */
    667 +          *out_try_again = TRUE;
    668 +          ret = TRUE;
    669 +          goto out;
    670 +        }
    671 +      else if (errno == EXDEV || errno == EMLINK || errno == EPERM
    672 +               || (enable_guestfs_fuse_workaround && errno == ENOENT))
    673 +        {
    674 +          if (!g_file_copy (src, tmp_dest, flags,
    675 +                            cancellable, NULL, NULL, error))
    676 +            goto out;
    677 +        }
    678 +      else
    679 +        {
    680 +          _set_error_from_errno (error);
    681 +          goto out;
    682 +        }
    683 +    }
    684 +     
    685 +  if (sync_data)
    686 +    {
    687 +      /* Now, we need to fsync */
    688 +      if (!gs_file_sync_data (tmp_dest, cancellable, error))
    689 +        goto out;
    690 +    }
    691 +
    692 +  if (!gs_file_rename (tmp_dest, dest, cancellable, error))
    693 +    goto out;
    694 +
    695 +  ret = TRUE;
    696 +  *out_try_again = FALSE;
    697 + out:
    698 +  g_clear_pointer (&tmp_name, g_free);
    699 +  g_clear_object (&tmp_dest);
    700 +  return ret;
    701 +}
    702 +
    703 +static gboolean
    704 +linkcopy_internal (GFile          *src,
    705 +                   GFile          *dest,
    706 +                   GFileCopyFlags  flags,
    707 +                   gboolean        sync_data,
    708 +                   GCancellable   *cancellable,
    709 +                   GError        **error)
    710 +{
    711 +  gboolean ret = FALSE;
    712 +  gboolean dest_exists;
    713 +  int i;
    714 +  gboolean enable_guestfs_fuse_workaround;
    715 +  struct stat src_stat;
    716 +  struct stat dest_stat;
    717 +  GFile *dest_parent = NULL;
    718 +
    719 +  flags |= G_FILE_COPY_NOFOLLOW_SYMLINKS;
    720 +
    721 +  g_return_val_if_fail ((flags & (G_FILE_COPY_BACKUP | G_FILE_COPY_TARGET_DEFAULT_PERMS)) == 0, FALSE);
    722 +
    723 +  dest_parent = g_file_get_parent (dest);
    724 +
    725 +  if (lstat (gs_file_get_path_cached (src), &src_stat) == -1)
    726 +    {
    727 +      int errsv = errno;
    728 +      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errno),
    729 +                           g_strerror (errsv));
    730 +      goto out;
    731 +    }
    732 +
    733 +  if (lstat (gs_file_get_path_cached (dest), &dest_stat) == -1)
    734 +    dest_exists = FALSE;
    735 +  else
    736 +    dest_exists = TRUE;
    737 
    738 +  if (((flags & G_FILE_COPY_OVERWRITE) == 0) && dest_exists)
    739 +    {
    740 +      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_EXISTS,
    741 +                           "File exists");
    742 +      goto out;
    743 +    }
    744 +
    745 +  /* Work around the behavior of link() where it's a no-op if src and
    746 +   * dest are the same.
    747 +   */
    748 +  if (dest_exists &&
    749 +      src_stat.st_dev == dest_stat.st_dev &&
    750 +      src_stat.st_ino == dest_stat.st_ino)
    751 +    {
    752 +      ret = TRUE;
    753 +      goto out;
    754 +    }
    755 +
    756 +  enable_guestfs_fuse_workaround = getenv ("LIBGSYSTEM_ENABLE_GUESTFS_FUSE_WORKAROUND") != NULL;
    757 +
    758 +  /* 128 attempts seems reasonable... */
    759 +  for (i = 0; i < 128; i++)
    760 +    {
    761 +      gboolean tryagain = FALSE;
    762 +
    763 +      if (!linkcopy_internal_attempt (src, dest, dest_parent,
    764 +                                      flags, sync_data,
    765 +                                      enable_guestfs_fuse_workaround,
    766 +                                      &tryagain,
    767 +                                      cancellable, error))
    768 +        goto out;
    769 +
    770 +      if (!tryagain)
    771 +        break;
    772 +    }
    773 +
    774 +  ret = TRUE;
    775 + out:
    776 +  g_clear_object (&dest_parent);
    777 +  return ret;
    778 +
    779 +}
    780 +
    781 +/**
    782 + * gs_file_linkcopy:
    783 + * @src: Source file
    784 + * @dest: Destination file
    785 + * @flags: flags
    786 + * @cancellable:
    787 + * @error:
    788 + *
    789 + * First tries to use the UNIX link() call, but if the files are on
    790 + * separate devices, fall back to copying via g_file_copy().
    791 + *
    792 + * The given @flags have different semantics than those documented
    793 + * when hardlinking is used.  Specifically, both
    794 + * #G_FILE_COPY_TARGET_DEFAULT_PERMS and #G_FILE_COPY_BACKUP are not
    795 + * supported.  #G_FILE_COPY_NOFOLLOW_SYMLINKS treated as if it was
    796 + * always given - if you want to follow symbolic links, you will need
    797 + * to resolve them manually.
    798 + *
    799 + * Beware - do not use this function if @src may be modified, and it's
    800 + * undesirable for the changes to also be reflected in @dest.  The
    801 + * best use of this function is in the case where @src and @dest are
    802 + * read-only, or where @src is a temporary file, and you want to put
    803 + * it in the final place.
    804 + */
    805 +gboolean
    806 +gs_file_linkcopy (GFile          *src,
    807 +                  GFile          *dest,
    808 +                  GFileCopyFlags  flags,
    809 +                  GCancellable   *cancellable,
    810 +                  GError        **error)
    811 +{
    812 +  return linkcopy_internal (src, dest, flags, FALSE, cancellable, error);
    813 +}
    814 +
    815 +/**
    816 + * gs_file_linkcopy_sync_data:
    817 + * @src: Source file
    818 + * @dest: Destination file
    819 + * @flags: flags
    820 + * @cancellable:
    821 + * @error:
    822 + *
    823 + * This function is similar to gs_file_linkcopy(), except it also uses
    824 + * gs_file_sync_data() to ensure that @dest is in stable storage
    825 + * before it is moved into place.
    826 + */
    827 +gboolean
    828 +gs_file_linkcopy_sync_data (GFile          *src,
    829 +                            GFile          *dest,
    830 +                            GFileCopyFlags  flags,
    831 +                            GCancellable   *cancellable,
    832 +                            GError        **error)
    833 +{
    834 +  return linkcopy_internal (src, dest, flags, TRUE, cancellable, error);
    835 +}
    836 +
    837 +static char *
    838 +gs_file_get_target_path (GFile *file)
    839 +{
    840 +  GFileInfo *info;
    841 +  const char *target;
    842 +  char *path;
    843 +
    844 +  info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI, G_FILE_QUERY_INFO_NONE, NULL, NULL);
    845 +  if (info == NULL)
    846 +    return NULL;
    847 +  target = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
    848 +  path = g_filename_from_uri (target, NULL, NULL);
    849 +  g_object_unref (info);
    850 +
    851 +  return path;
    852 +}
    853 +
    854 +G_LOCK_DEFINE_STATIC (pathname_cache);
    855 +
    856 +/**
    857 + * gs_file_get_path_cached:
    858 + *
    859 + * Like g_file_get_path(), but returns a constant copy so callers
    860 + * don't need to free the result.
    861 + */
    862 +const char *
    863 +gs_file_get_path_cached (GFile *file)
    864 +{
    865 +  const char *path;
    866 +  static GQuark _file_path_quark = 0;
    867 +
    868 +  if (G_UNLIKELY (_file_path_quark) == 0)
    869 +    _file_path_quark = g_quark_from_static_string ("gsystem-file-path");
    870 +
    871 +  G_LOCK (pathname_cache);
    872 +
    873 +  path = g_object_get_qdata ((GObject*)file, _file_path_quark);
    874 +  if (!path)
    875 +    {
    876 +      if (g_file_has_uri_scheme (file, "trash") ||
    877 +          g_file_has_uri_scheme (file, "recent"))
    878 +        path = gs_file_get_target_path (file);
    879 +      else
    880 +        path = g_file_get_path (file);
    881 +      if (path == NULL)
    882 +        {
    883 +          G_UNLOCK (pathname_cache);
    884 +          return NULL;
    885 +        }
    886 +      g_object_set_qdata_full ((GObject*)file, _file_path_quark, (char*)path, (GDestroyNotify)g_free);
    887 +    }
    888 +
    889 +  G_UNLOCK (pathname_cache);
    890 +
    891 +  return path;
    892 +}
    893 +
    894 +/**
    895 + * gs_file_get_basename_cached:
    896 + *
    897 + * Like g_file_get_basename(), but returns a constant copy so callers
    898 + * don't need to free the result.
    899 + */
    900 +const char *
    901 +gs_file_get_basename_cached (GFile *file)
    902 +{
    903 +  const char *name;
    904 +  static GQuark _file_name_quark = 0;
    905 +
    906 +  if (G_UNLIKELY (_file_name_quark) == 0)
    907 +    _file_name_quark = g_quark_from_static_string ("gsystem-file-name");
    908 +
    909 +  G_LOCK (pathname_cache);
    910 +
    911 +  name = g_object_get_qdata ((GObject*)file, _file_name_quark);
    912 +  if (!name)
    913 +    {
    914 +      name = g_file_get_basename (file);
    915 +      g_object_set_qdata_full ((GObject*)file, _file_name_quark, (char*)name, (GDestroyNotify)g_free);
    916 +    }
    917 +
    918 +  G_UNLOCK (pathname_cache);
    919 +
    920 +  return name;
    921 +}
    922 +
    923 +/**
    924 + * gs_file_enumerator_iterate:
    925 + * @direnum: an open #GFileEnumerator
    926 + * @out_info: (out) (transfer none) (allow-none): Output location for the next #GFileInfo
    927 + * @out_child: (out) (transfer none) (allow-none): Output location for the next #GFile, or %NULL
    928 + * @cancellable: a #GCancellable
    929 + * @error: a #GError
    930 + *
    931 + * This is a version of g_file_enumerator_next_file() that's easier to
    932 + * use correctly from C programs.  With g_file_enumerator_next_file(),
    933 + * the gboolean return value signifies "end of iteration or error", which
    934 + * requires allocation of a temporary #GError.
    935 + *
    936 + * In contrast, with this function, a %FALSE return from
    937 + * gs_file_enumerator_iterate() <emphasis>always</emphasis> means
    938 + * "error".  End of iteration is signaled by @out_info being %NULL.
    939 + *
    940 + * Another crucial difference is that the references for @out_info and
    941 + * @out_child are owned by @direnum (they are cached as hidden
    942 + * properties).  You must not unref them in your own code.  This makes
    943 + * memory management significantly easier for C code in combination
    944 + * with loops.
    945 + *
    946 + * Finally, this function optionally allows retrieving a #GFile as
    947 + * well.
    948 + *
    949 + * The code pattern for correctly using gs_file_enumerator_iterate() from C
    950 + * is:
    951 + *
    952 + * |[
    953 + * direnum = g_file_enumerate_children (file, ...);
    954 + * while (TRUE)
    955 + *   {
    956 + *     GFileInfo *info;
    957 + *     if (!gs_file_enumerator_iterate (direnum, &info, NULL, cancellable, error))
    958 + *       goto out;
    959 + *     if (!info)
    960 + *       break;
    961 + *     ... do stuff with "info"; do not unref it! ...
    962 + *   }
    963 + *
    964 + * out:
    965 + *   g_object_unref (direnum); // Note: frees the last @info
    966 + * ]|
    967 + */
    968 +gboolean
    969 +gs_file_enumerator_iterate (GFileEnumerator  *direnum,
    970 +                            GFileInfo       **out_info,
    971 +                            GFile           **out_child,
    972 +                            GCancellable     *cancellable,
    973 +                            GError          **error)
    974 +{
    975 +  gboolean ret = FALSE;
    976 +  GError *temp_error = NULL;
    977 +
    978 +  static GQuark cached_info_quark;
    979 +  static GQuark cached_child_quark;
    980 +  static gsize quarks_initialized;
    981 +
    982 +  g_return_val_if_fail (direnum != NULL, FALSE);
    983 +  g_return_val_if_fail (out_info != NULL, FALSE);
    984 +
    985 +  if (g_once_init_enter (&quarks_initialized))
    986 +    {
    987 +      cached_info_quark = g_quark_from_static_string ("gsystem-cached-info");
    988 +      cached_child_quark = g_quark_from_static_string ("gsystem-cached-child");
    989 +      g_once_init_leave (&quarks_initialized, 1);
    990 +    }
    991 +
    992 
    993 +  *out_info = g_file_enumerator_next_file (direnum, cancellable, &temp_error);
    994 +  if (out_child)
    995 +    *out_child = NULL;
    996 +  if (temp_error != NULL)
    997 +    {
    998 +      g_propagate_error (error, temp_error);
    999 +      goto out;
    1000 +    }
    1001 +  else if (*out_info != NULL)
    1002 +    {
    1003 +      g_object_set_qdata_full ((GObject*)direnum, cached_info_quark, *out_info, (GDestroyNotify)g_object_unref);
    1004 +      if (out_child != NULL)
    1005 +        {
    1006 +          const char *name = g_file_info_get_name (*out_info);
    1007 +          *out_child = g_file_get_child (g_file_enumerator_get_container (direnum), name);
    1008 +          g_object_set_qdata_full ((GObject*)direnum, cached_child_quark, *out_child, (GDestroyNotify)g_object_unref);
    1009 +        }
    1010 +    }
    1011 +
    1012 +  ret = TRUE;
    1013 + out:
    1014 +  return ret;
    1015 +}
    1016 +
    1017 +/**
    1018 + * gs_file_rename:
    1019 + * @from: Current path
    1020 + * @to: New path
    1021 + * @cancellable: a #GCancellable
    1022 + * @error: a #GError
    1023 + *
    1024 + * This function wraps the raw Unix function rename().
    1025 + *
    1026 + * Returns: %TRUE on success, %FALSE on error
    1027 + */
    1028 +gboolean
    1029 +gs_file_rename (GFile          *from,
    1030 +                GFile          *to,
    1031 +                GCancellable   *cancellable,
    1032 +                GError        **error)
    1033 +{
    1034 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    1035 +    return FALSE;
    1036 +
    1037 +  if (rename (gs_file_get_path_cached (from),
    1038 +              gs_file_get_path_cached (to)) < 0)
    1039 +    {
    1040 +      _set_error_from_errno (error);
    1041 +      return FALSE;
    1042 +    }
    1043 +  return TRUE;
    1044 +}
    1045 +
    1046 +/**
    1047 + * gs_file_unlink:
    1048 + * @path: Path to file
    1049 + * @cancellable: a #GCancellable
    1050 + * @error: a #GError
    1051 + *
    1052 + * Like g_file_delete(), except this function does not follow Unix
    1053 + * symbolic links, and will delete a symbolic link even if it's
    1054 + * pointing to a nonexistent file.  In other words, this function
    1055 + * merely wraps the raw Unix function unlink().
    1056 + *
    1057 + * Returns: %TRUE on success, %FALSE on error
    1058 + */
    1059 +gboolean
    1060 +gs_file_unlink (GFile          *path,
    1061 +                GCancellable   *cancellable,
    1062 +                GError        **error)
    1063 +{
    1064 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    1065 +    return FALSE;
    1066 +
    1067 +  if (unlink (gs_file_get_path_cached (path)) < 0)
    1068 +    {
    1069 +      _set_error_from_errno (error);
    1070 +      return FALSE;
    1071 +    }
    1072 +  return TRUE;
    1073 +}
    1074 +
    1075 +static gboolean
    1076 +chown_internal (GFile          *path,
    1077 +                gboolean        dereference_links,
    1078 +                guint32         owner,
    1079 +                guint32         group,
    1080 +                GCancellable   *cancellable,
    1081 +                GError        **error)
    1082 +{
    1083 +  gboolean ret = FALSE;
    1084 +  int res;
    1085 +
    1086 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    1087 +    return FALSE;
    1088 +
    1089 +  do
    1090 +    if (dereference_links)
    1091 +      res = chown (gs_file_get_path_cached (path), owner, group);
    1092 +    else
    1093 +      res = lchown (gs_file_get_path_cached (path), owner, group);
    1094 +  while (G_UNLIKELY (res != 0 && errno == EINTR));
    1095 +
    1096 +  if (res < 0)
    1097 +    {
    1098 +      _set_error_from_errno (error);
    1099 +      goto out;
    1100 +    }
    1101 +
    1102 +  ret = TRUE;
    1103 + out:
    1104 +  return ret;
    1105 +}
    1106 +
    1107 +/**
    1108 + * gs_file_chown:
    1109 + * @path: Path to file
    1110 + * @owner: UNIX owner
    1111 + * @group: UNIX group
    1112 + * @cancellable: a #GCancellable
    1113 + * @error: a #GError
    1114 + *
    1115 + * Merely wraps UNIX chown().
    1116 + *
    1117 + * Returns: %TRUE on success, %FALSE on error
    1118 + */
    1119 +gboolean
    1120 +gs_file_chown (GFile          *path,
    1121 +               guint32         owner,
    1122 +               guint32         group,
    1123 +               GCancellable   *cancellable,
    1124 +               GError        **error)
    1125 +{
    1126 +  return chown_internal (path, TRUE, owner, group, cancellable, error);
    1127 +}
    1128 +
    1129 +/**
    1130 + * gs_file_lchown:
    1131 + * @path: Path to file
    1132 + * @owner: UNIX owner
    1133 + * @group: UNIX group
    1134 + * @cancellable: a #GCancellable
    1135 + * @error: a #GError
    1136 + *
    1137 + * Merely wraps UNIX lchown().
    1138 + *
    1139 + * Returns: %TRUE on success, %FALSE on error
    1140 + */
    1141 +gboolean
    1142 +gs_file_lchown (GFile          *path,
    1143 +                guint32         owner,
    1144 +                guint32         group,
    1145 +                GCancellable   *cancellable,
    1146 +                GError        **error)
    1147 +{
    1148 +  return chown_internal (path, FALSE, owner, group, cancellable, error);
    1149 +}
    1150 +
    1151 +/**
    1152 + * gs_file_chmod:
    1153 + * @path: Path to file
    1154 + * @mode: UNIX mode
    1155 + * @cancellable: a #GCancellable
    1156 + * @error: a #GError
    1157 + *
    1158 + * Merely wraps UNIX chmod().
    1159 + *
    1160 + * Returns: %TRUE on success, %FALSE on error
    1161 + */
    1162 +gboolean
    1163 +gs_file_chmod (GFile          *path,
    1164 +               guint           mode,
    1165 +               GCancellable   *cancellable,
    1166 +               GError        **error)
    1167 +{
    1168 +  gboolean ret = FALSE;
    1169 +  int res;
    1170 +
    1171 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    1172 +    return FALSE;
    1173 +
    1174 +  do
    1175 +    res = chmod (gs_file_get_path_cached (path), mode);
    1176 +  while (G_UNLIKELY (res != 0 && errno == EINTR));
    1177 +
    1178 +  if (res < 0)
    1179 +    {
    1180 +      _set_error_from_errno (error);
    1181 +      goto out;
    1182 +    }
    1183 +
    1184 +  ret = TRUE;
    1185 + out:
    1186 +  return ret;
    1187 +}
    1188 +
    1189 +/**
    1190 + * gs_file_ensure_directory:
    1191 + * @dir: Path to create as directory
    1192 + * @with_parents: Also create parent directories
    1193 + * @cancellable: a #GCancellable
    1194 + * @error: a #GError
    1195 + *
    1196 + * Like g_file_make_directory(), except does not throw an error if the
    1197 + * directory already exists.
    1198 + */
    1199 +gboolean
    1200 +gs_file_ensure_directory (GFile         *dir,
    1201 +                          gboolean       with_parents,
    1202 +                          GCancellable  *cancellable,
    1203 +                          GError       **error)
    1204 +{
    1205 +  gboolean ret = FALSE;
    1206 +  GError *temp_error = NULL;
    1207 +  GFile *parent = NULL;
    1208 +
    1209 +  if (!g_file_make_directory (dir, cancellable, &temp_error))
    1210 +    {
    1211 +      if (with_parents &&
    1212 +          g_error_matches (temp_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
    1213 +        {
    1214 +          g_clear_error (&temp_error);
    1215 +
    1216 +          parent = g_file_get_parent (dir);
    1217 +          if (parent)
    1218 +            {
    1219 +              if (!gs_file_ensure_directory (parent, TRUE, cancellable, error))
    1220 +                goto out;
    1221 +            }
    1222 +          if (!gs_file_ensure_directory (dir, FALSE, cancellable, error))
    1223 +            goto out;
    1224 +        }
    1225 +      else if (!g_error_matches (temp_error, G_IO_ERROR, G_IO_ERROR_EXISTS))
    1226 +        {
    1227 +          g_propagate_error (error, temp_error);
    1228 +          goto out;
    1229 +        }
    1230 +      else
    1231 +        g_clear_error (&temp_error);
    1232 +    }
    1233 +
    1234 +  ret = TRUE;
    1235 + out:
    1236 +  g_clear_object (&parent);
    1237 +  return ret;
    1238 +}
    1239 +
    1240 +/**
    1241 + * gs_file_ensure_directory_mode:
    1242 + * @dir: Path to create as directory
    1243 + * @mode: Create directory with these permissions
    1244 + * @cancellable: a #GCancellable
    1245 + * @error: a #GError
    1246 + *
    1247 + * Wraps UNIX mkdir() function with support for @cancellable, and
    1248 + * uses @error instead of errno.
    1249 + */
    1250 +gboolean
    1251 +gs_file_ensure_directory_mode (GFile         *dir,
    1252 +                               guint          mode,
    1253 +                               GCancellable  *cancellable,
    1254 +                               GError       **error)
    1255 +{
    1256 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    1257 +    return FALSE;
    1258 +
    1259 +  if (mkdir (gs_file_get_path_cached (dir), mode) == -1 && errno != EEXIST)
    1260 +    {
    1261 +      _set_error_from_errno (error);
    1262 +      return FALSE;
    1263 +    }
    1264 +  return TRUE;
    1265 +}
    1266 +
    1267 +/**
    1268 + * gs_file_load_contents_utf8:
    1269 + * @file: Path to file whose contents must be UTF-8
    1270 + * @cancellable:
    1271 + * @error:
    1272 + *
    1273 + * Like g_file_load_contents(), except validates the contents are
    1274 + * UTF-8.
    1275 + */
    1276 +gchar *
    1277 +gs_file_load_contents_utf8 (GFile         *file,
    1278 +                            GCancellable  *cancellable,
    1279 +                            GError       **error)
    1280 +{
    1281 +  gboolean ret = FALSE;
    1282 +  gsize len;
    1283 +  char *ret_contents = NULL;
    1284 +
    1285 +  if (!g_file_load_contents (file, cancellable, &ret_contents, &len,
    1286 +                             NULL, error))
    1287 +    goto out;
    1288 +  if (!g_utf8_validate (ret_contents, len, NULL))
    1289 +    {
    1290 +      g_set_error (error,
    1291 +                   G_IO_ERROR,
    1292 +                   G_IO_ERROR_INVALID_DATA,
    1293 +                   "Invalid UTF-8");
    1294 +      goto out;
    1295 +    }
    1296 +
    1297 +  ret = TRUE;
    1298 + out:
    1299 +  if (!ret)
    1300 +    {
    1301 +      g_free (ret_contents);
    1302 +      return NULL;
    1303 +    }
    1304 +  return ret_contents;
    1305 +}
    1306 +
    1307 +static int
    1308 +path_common_directory (char *one,
    1309 +                       char *two)
    1310 +{
    1311 +  int dir_index = 0;
    1312 +  int i = 0;
    1313 +
    1314 +  while (*one && *two)
    1315 +    {
    1316 +      if (*one != *two)
    1317 +        break;
    1318 +      if (*one == '/')
    1319 +        dir_index = i + 1;
    1320 +
    1321 +      one++;
    1322 +      two++;
    1323 +      i++;
    1324 +    }
    1325 +
    1326 +  return dir_index;
    1327 +}
    1328 +
    1329 +/**
    1330 + * gs_file_get_relpath:
    1331 + * @one: The first #GFile
    1332 + * @two: The second #GFile
    1333 + *
    1334 + * Like gs_file_get_relative_path(), but does not mandate that
    1335 + * the two files have any parent in common. This function will
    1336 + * instead insert "../" where appropriate.
    1337 + *
    1338 + * Returns: (transfer full): The relative path between the two.
    1339 + */
    1340 +gchar *
    1341 +gs_file_get_relpath (GFile *one,
    1342 +                     GFile *two)
    1343 +{
    1344 +  gchar *simple_path;
    1345 +  gchar *one_path, *one_suffix;
    1346 +  gchar *two_path, *two_suffix;
    1347 +  GString *path;
    1348 +  int i;
    1349 +
    1350 +  simple_path = g_file_get_relative_path (one, two);
    1351 +  if (simple_path)
    1352 +    return simple_path;
    1353 +
    1354 +  one_path = g_file_get_path (one);
    1355 +  two_path = g_file_get_path (two);
    1356 +
    1357 +  i = path_common_directory (one_path, two_path);
    1358 +  one_suffix = one_path + i;
    1359 +  two_suffix = two_path + i;
    1360 +
    1361 +  path = g_string_new ("");
    1362 +
    1363 +  /* For every leftover path segment one has, append "../" so
    1364 +   * that we reach the same directory. */
    1365 +  while (*one_suffix)
    1366 +    {
    1367 +      g_string_append (path, "../");
    1368 +      one_suffix = strchr (one_suffix, '/');
    1369 +      if (one_suffix == NULL)
    1370 +        break;
    1371 +      one_suffix++;
    1372 +    }
    1373 +
    1374 +  /* And now append the leftover stuff on two's side. */
    1375 +  g_string_append (path, two_suffix);
    1376 +
    1377 +  g_free (one_path);
    1378 +  g_free (two_path);
    1379 +
    1380 +  return g_string_free (path, FALSE);
    1381 +}
    1382 +
    1383 +/**
    1384 + * gs_file_realpath:
    1385 + * @file: A #GFile
    1386 + *
    1387 + * Return a #GFile that contains the same path with symlinks
    1388 + * followed. That is, it's a #GFile whose path is the result
    1389 + * of calling realpath() on @file.
    1390 + *
    1391 + * Returns: (allow-none) (transfer full): A new #GFile or %NULL if @file is invalid
    1392 + */
    1393 +GFile *
    1394 +gs_file_realpath (GFile *file)
    1395 +{
    1396 +  gchar *path;
    1397 +  gchar path_real[PATH_MAX];
    1398 +
    1399 +  path = g_file_get_path (file);
    1400 +
    1401 +  if (realpath ((const char *) path, path_real) == NULL)
    1402 +    {
    1403 +      g_free (path);
    1404 +      return NULL;
    1405 +    }
    1406 +
    1407 +  g_free (path);
    1408 +  return g_file_new_for_path (path_real);
    1409 +}
    1410 +
    1411 +#ifdef GSYSTEM_CONFIG_XATTRS
    1412 +static char *
    1413 +canonicalize_xattrs (char    *xattr_string,
    1414 +                     size_t   len)
    1415 +{
    1416 +  char *p;
    1417 +  GSList *xattrs = NULL;
    1418 +  GSList *iter;
    1419 +  GString *result;
    1420 +
    1421 +  result = g_string_new (0);
    1422 +
    1423 +  p = xattr_string;
    1424 +  while (p < xattr_string+len)
    1425 +    {
    1426 +      xattrs = g_slist_prepend (xattrs, p);
    1427 +      p += strlen (p) + 1;
    1428 +    }
    1429 +
    1430 +  xattrs = g_slist_sort (xattrs, (GCompareFunc) strcmp);
    1431 +  for (iter = xattrs; iter; iter = iter->next) {
    1432 +    g_string_append (result, iter->data);
    1433 +    g_string_append_c (result, '\0');
    1434 +  }
    1435 +
    1436 +  g_slist_free (xattrs);
    1437 +  return g_string_free (result, FALSE);
    1438 +}
    1439 +
    1440 +static GVariant *
    1441 +variant_new_ay_bytes (GBytes *bytes)
    1442 +{
    1443 +  gsize size;
    1444 +  gconstpointer data;
    1445 +  data = g_bytes_get_data (bytes, &size);
    1446 +  g_bytes_ref (bytes);
    1447 +  return g_variant_new_from_data (G_VARIANT_TYPE ("ay"), data, size,
    1448 +                                  TRUE, (GDestroyNotify)g_bytes_unref, bytes);
    1449 +}
    1450 +
    1451 +static gboolean
    1452 +read_xattr_name_array (const char *path,
    1453 +                       const char *xattrs,
    1454 +                       size_t      len,
    1455 +                       GVariantBuilder *builder,
    1456 +                       GError  **error)
    1457 +{
    1458 +  gboolean ret = FALSE;
    1459 +  const char *p;
    1460 +
    1461 +  p = xattrs;
    1462 +  while (p < xattrs+len)
    1463 +    {
    1464 +      ssize_t bytes_read;
    1465 +      char *buf;
    1466 +      GBytes *bytes = NULL;
    1467 +
    1468 +      bytes_read = lgetxattr (path, p, NULL, 0);
    1469 +      if (bytes_read < 0)
    1470 +        {
    1471 +          _set_error_from_errno (error);
    1472 +          g_prefix_error (error, "lgetxattr (%s, %s) failed: ", path, p);
    1473 +          goto out;
    1474 +        }
    1475 +      if (bytes_read == 0)
    1476 +        continue;
    1477 +
    1478 +      buf = g_malloc (bytes_read);
    1479 +      bytes = g_bytes_new_take (buf, bytes_read);
    1480 +      if (lgetxattr (path, p, buf, bytes_read) < 0)
    1481 +        {
    1482 +          g_bytes_unref (bytes);
    1483 +          _set_error_from_errno (error);
    1484 +          g_prefix_error (error, "lgetxattr (%s, %s) failed: ", path, p);
    1485 +          goto out;
    1486 +        }
    1487 +     
    1488 +      g_variant_builder_add (builder, "(@ay@ay)",
    1489 +                             g_variant_new_bytestring (p),
    1490 +                             variant_new_ay_bytes (bytes));
    1491 +
    1492 +      p = p + strlen (p) + 1;
    1493 +      g_bytes_unref (bytes);
    1494 +    }
    1495 
    1496 +  ret = TRUE;
    1497 + out:
    1498 +  return ret;
    1499 +}
    1500 +
    1501 +#endif
    1502 +
    1503 +/**
    1504 + * gs_file_get_all_xattrs:
    1505 + * @f: a #GFile
    1506 + * @out_xattrs: (out): A new #GVariant containing the extended attributes
    1507 + * @cancellable: Cancellable
    1508 + * @error: Error
    1509 + *
    1510 + * Read all extended attributes of @f in a canonical sorted order, and
    1511 + * set @out_xattrs with the result.
    1512 + *
    1513 + * If the filesystem does not support extended attributes, @out_xattrs
    1514 + * will have 0 elements, and this function will return successfully.
    1515 + */
    1516 +gboolean
    1517 +gs_file_get_all_xattrs (GFile         *f,
    1518 +                        GVariant     **out_xattrs,
    1519 +                        GCancellable  *cancellable,
    1520 +                        GError       **error)
    1521 +{
    1522 +  gboolean ret = FALSE;
    1523 +  const char *path;
    1524 +  ssize_t bytes_read;
    1525 +  GVariant *ret_xattrs = NULL;
    1526 +  char *xattr_names = NULL;
    1527 +  char *xattr_names_canonical = NULL;
    1528 +  GVariantBuilder builder;
    1529 +  gboolean builder_initialized = FALSE;
    1530 +
    1531 +  path = gs_file_get_path_cached (f);
    1532 +
    1533 +  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(ayay)"));
    1534 +  builder_initialized = TRUE;
    1535 +
    1536 +#ifdef GSYSTEM_CONFIG_XATTRS
    1537 +  bytes_read = llistxattr (path, NULL, 0);
    1538 +
    1539 +  if (bytes_read < 0)
    1540 +    {
    1541 +      if (errno != ENOTSUP)
    1542 +        {
    1543 +          _set_error_from_errno (error);
    1544 +          g_prefix_error (error, "llistxattr (%s) failed: ", path);
    1545 +          goto out;
    1546 +        }
    1547 +    }
    1548 +  else if (bytes_read > 0)
    1549 +    {
    1550 +      xattr_names = g_malloc (bytes_read);
    1551 +      if (llistxattr (path, xattr_names, bytes_read) < 0)
    1552 +        {
    1553 +          _set_error_from_errno (error);
    1554 +          g_prefix_error (error, "llistxattr (%s) failed: ", path);
    1555 +          goto out;
    1556 +        }
    1557 +      xattr_names_canonical = canonicalize_xattrs (xattr_names, bytes_read);
    1558 +     
    1559 +      if (!read_xattr_name_array (path, xattr_names_canonical, bytes_read, &builder, error))
    1560 +        goto out;
    1561 +    }
    1562 +
    1563 +#endif
    1564 +
    1565 +  ret_xattrs = g_variant_builder_end (&builder);
    1566 +  g_variant_ref_sink (ret_xattrs);
    1567 
    1568 +  ret = TRUE;
    1569 +  gs_transfer_out_value (out_xattrs, &ret_xattrs);
    1570 + out:
    1571 +  g_clear_pointer (&ret_xattrs, g_variant_unref);
    1572 +  g_clear_pointer (&xattr_names, g_free);
    1573 +  g_clear_pointer (&xattr_names_canonical, g_free);
    1574 +  if (!builder_initialized)
    1575 +    g_variant_builder_clear (&builder);
    1576 +  return ret;
    1577 +}
    1578 +
    1579 +/**
    1580 + * gs_fd_set_all_xattrs:
    1581 + * @fd: File descriptor
    1582 + * @xattrs: Extended attributes
    1583 + * @cancellable: Cancellable
    1584 + * @error: Error
    1585 + *
    1586 + * For each attribute in @xattrs, set its value on the file or
    1587 + * directory referred to by @fd.  This function does not remove any
    1588 + * attributes not in @xattrs.
    1589 + */
    1590 +gboolean
    1591 +gs_fd_set_all_xattrs (int            fd,
    1592 +                      GVariant      *xattrs,
    1593 +                      GCancellable  *cancellable,
    1594 +                      GError       **error)
    1595 +{
    1596 +#ifdef GSYSTEM_CONFIG_XATTRS
    1597 +  gboolean ret = FALSE;
    1598 +  int i, n;
    1599 +
    1600 +  n = g_variant_n_children (xattrs);
    1601 +  for (i = 0; i < n; i++)
    1602 +    {
    1603 +      const guint8* name;
    1604 +      const guint8* value_data;
    1605 +      GVariant *value = NULL;
    1606 +      gsize value_len;
    1607 +      int res;
    1608 +
    1609 +      g_variant_get_child (xattrs, i, "(^&ay@ay)",
    1610 +                           &name, &value);
    1611 +      value_data = g_variant_get_fixed_array (value, &value_len, 1);
    1612 +     
    1613 +      do
    1614 +        res = fsetxattr (fd, (char*)name, (char*)value_data, value_len, 0);
    1615 +      while (G_UNLIKELY (res == -1 && errno == EINTR));
    1616 +      g_variant_unref (value);
    1617 +      if (G_UNLIKELY (res == -1))
    1618 +        {
    1619 +          _set_error_from_errno (error);
    1620 +          goto out;
    1621 +        }
    1622 +    }
    1623 +
    1624 +  ret = TRUE;
    1625 + out:
    1626 +  return ret;
    1627 +#else
    1628 +  return TRUE;
    1629 +#endif
    1630 +}
    1631 +
    1632 +/**
    1633 + * gs_file_set_all_xattrs:
    1634 + * @file: File descriptor
    1635 + * @xattrs: Extended attributes
    1636 + * @cancellable: Cancellable
    1637 + * @error: Error
    1638 + *
    1639 + * For each attribute in @xattrs, set its value on the file or
    1640 + * directory referred to by @file.  This function does not remove any
    1641 + * attributes not in @xattrs.
    1642 + */
    1643 +gboolean
    1644 +gs_file_set_all_xattrs (GFile         *file,
    1645 +                        GVariant      *xattrs,
    1646 +                        GCancellable  *cancellable,
    1647 +                        GError       **error)
    1648 +{
    1649 +#ifdef GSYSTEM_CONFIG_XATTRS
    1650 +  gboolean ret = FALSE;
    1651 +  const char *path;
    1652 +  int i, n;
    1653 +
    1654 +  path = gs_file_get_path_cached (file);
    1655 +
    1656 +  n = g_variant_n_children (xattrs);
    1657 +  for (i = 0; i < n; i++)
    1658 +    {
    1659 +      const guint8* name;
    1660 +      GVariant *value;
    1661 +      const guint8* value_data;
    1662 +      gsize value_len;
    1663 +      gboolean loop_err;
    1664 +
    1665 +      g_variant_get_child (xattrs, i, "(^&ay@ay)",
    1666 +                           &name, &value);
    1667 +      value_data = g_variant_get_fixed_array (value, &value_len, 1);
    1668 +     
    1669 +      loop_err = lsetxattr (path, (char*)name, (char*)value_data, value_len, 0) < 0;
    1670 +      g_clear_pointer (&value, (GDestroyNotify) g_variant_unref);
    1671 +      if (loop_err)
    1672 +        {
    1673 +          _set_error_from_errno (error);
    1674 +          g_prefix_error (error, "lsetxattr (%s, %s) failed: ", path, name);
    1675 +          goto out;
    1676 +        }
    1677 +    }
    1678 +
    1679 +  ret = TRUE;
    1680 + out:
    1681 +  return ret;
    1682 +#else
    1683 +  return TRUE;
    1684 +#endif
    1685 +}
    168656diff -urN libgnome-desktop/libgsystem.orig/gsystem-osx-compat.c libgnome-desktop/libgsystem/gsystem-osx-compat.c
    168757--- libgnome-desktop/libgsystem.orig/gsystem-osx-compat.c       1969-12-31 16:00:00.000000000 -0800
     
    2442812       d = fdopendir (dfd);
    2443813       if (!d)
    2444 diff -urN libgnome-desktop/libgsystem.orig/gsystem-shutil.c.orig libgnome-desktop/libgsystem/gsystem-shutil.c.orig
    2445 --- libgnome-desktop/libgsystem.orig/gsystem-shutil.c.orig      1969-12-31 16:00:00.000000000 -0800
    2446 +++ libgnome-desktop/libgsystem/gsystem-shutil.c.orig   2014-01-15 13:06:25.000000000 -0800
    2447 @@ -0,0 +1,459 @@
    2448 +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
    2449 + *
    2450 + * Copyright (C) 2012 William Jon McCann <mccann@redhat.com>
    2451 + * Copyright (C) 2012 Colin Walters <walters@verbum.org>
    2452 + *
    2453 + * This library is free software; you can redistribute it and/or
    2454 + * modify it under the terms of the GNU Lesser General Public
    2455 + * License as published by the Free Software Foundation; either
    2456 + * version 2 of the License, or (at your option) any later version.
    2457 + *
    2458 + * This library is distributed in the hope that it will be useful,
    2459 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    2460 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    2461 + * Lesser General Public License for more details.
    2462 + *
    2463 + * You should have received a copy of the GNU Lesser General Public
    2464 + * License along with this library; if not, write to the
    2465 + * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    2466 + * Boston, MA 02111-1307, USA.
    2467 + */
    2468 +
    2469 +#include "config.h"
    2470 +
    2471 +#ifndef _GNU_SOURCE
    2472 +#define _GNU_SOURCE
    2473 +#endif
    2474 +
    2475 +#define _GSYSTEM_NO_LOCAL_ALLOC
    2476 +#include "libgsystem.h"
    2477 +#include <glib-unix.h>
    2478 +#include <string.h>
    2479 +#include <sys/stat.h>
    2480 +#include <dirent.h>
    2481 +#include <fcntl.h>
    2482 +
    2483 +/* Taken from systemd/src/shared/util.h */
    2484 +union dirent_storage {
    2485 +        struct dirent dent;
    2486 +        guint8 storage[offsetof(struct dirent, d_name) +
    2487 +                        ((NAME_MAX + 1 + sizeof(long)) & ~(sizeof(long) - 1))];
    2488 +};
    2489 +
    2490 +static inline void
    2491 +_set_error_from_errno (GError **error)
    2492 +{
    2493 +  int errsv = errno;
    2494 +  g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2495 +                       g_strerror (errsv));
    2496 +}
    2497 +
    2498 +static gboolean
    2499 +copy_xattrs_from_file_to_fd (GFile         *src,
    2500 +                             int            dest_fd,
    2501 +                             GCancellable  *cancellable,
    2502 +                             GError       **error)
    2503 +{
    2504 +  gboolean ret = FALSE;
    2505 +  GVariant *src_xattrs = NULL;
    2506 +
    2507 +  if (!gs_file_get_all_xattrs (src, &src_xattrs, cancellable, error))
    2508 +    goto out;
    2509 +
    2510 +  if (src_xattrs)
    2511 +    {
    2512 +      if (!gs_fd_set_all_xattrs (dest_fd, src_xattrs, cancellable, error))
    2513 +        goto out;
    2514 +    }
    2515 +
    2516 +  ret = TRUE;
    2517 + out:
    2518 +  g_clear_pointer (&src_xattrs, g_variant_unref);
    2519 +  return ret;
    2520 +}
    2521 +
    2522 +typedef enum {
    2523 +  GS_CP_MODE_NONE,
    2524 +  GS_CP_MODE_HARDLINK,
    2525 +  GS_CP_MODE_COPY_ALL
    2526 +} GsCpMode;
    2527 +
    2528 +static gboolean
    2529 +cp_internal (GFile         *src,
    2530 +             GFile         *dest,
    2531 +             GsCpMode       mode,
    2532 +             GCancellable  *cancellable,
    2533 +             GError       **error)
    2534 +{
    2535 +  gboolean ret = FALSE;
    2536 +  GFileEnumerator *enumerator = NULL;
    2537 +  GFileInfo *src_info = NULL;
    2538 +  GFile *dest_child = NULL;
    2539 +  int dest_dfd = -1;
    2540 +  int r;
    2541 +
    2542 +  enumerator = g_file_enumerate_children (src, "standard::type,standard::name,unix::uid,unix::gid,unix::mode",
    2543 +                                          G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
    2544 +                                          cancellable, error);
    2545 +  if (!enumerator)
    2546 +    goto out;
    2547 +
    2548 +  src_info = g_file_query_info (src, "standard::name,unix::mode,unix::uid,unix::gid," \
    2549 +                                "time::modified,time::modified-usec,time::access,time::access-usec",
    2550 +                                G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
    2551 +                                cancellable, error);
    2552 +  if (!src_info)
    2553 +    goto out;
    2554 +
    2555 +  do
    2556 +    r = mkdir (gs_file_get_path_cached (dest), 0755);
    2557 +  while (G_UNLIKELY (r == -1 && errno == EINTR));
    2558 +  if (r == -1)
    2559 +    {
    2560 +      _set_error_from_errno (error);
    2561 +      goto out;
    2562 +    }
    2563 +
    2564 +  if (mode != GS_CP_MODE_NONE)
    2565 +    {
    2566 +      if (!gs_file_open_dir_fd (dest, &dest_dfd,
    2567 +                                cancellable, error))
    2568 +        goto out;
    2569 +
    2570 +      do
    2571 +        r = fchown (dest_dfd,
    2572 +                    g_file_info_get_attribute_uint32 (src_info, "unix::uid"),
    2573 +                    g_file_info_get_attribute_uint32 (src_info, "unix::gid"));
    2574 +      while (G_UNLIKELY (r == -1 && errno == EINTR));
    2575 +      if (r == -1)
    2576 +        {
    2577 +          _set_error_from_errno (error);
    2578 +          goto out;
    2579 +        }
    2580 +
    2581 +      do
    2582 +        r = fchmod (dest_dfd, g_file_info_get_attribute_uint32 (src_info, "unix::mode"));
    2583 +      while (G_UNLIKELY (r == -1 && errno == EINTR));
    2584 +
    2585 +      if (!copy_xattrs_from_file_to_fd (src, dest_dfd, cancellable, error))
    2586 +        goto out;
    2587 +
    2588 +      if (dest_dfd != -1)
    2589 +        {
    2590 +          (void) close (dest_dfd);
    2591 +          dest_dfd = -1;
    2592 +        }
    2593 +    }
    2594 +
    2595 +  while (TRUE)
    2596 +    {
    2597 +      GFileInfo *file_info = NULL;
    2598 +      GFile *src_child = NULL;
    2599 +
    2600 +      if (!gs_file_enumerator_iterate (enumerator, &file_info, &src_child,
    2601 +                                       cancellable, error))
    2602 +        goto out;
    2603 +      if (!file_info)
    2604 +        break;
    2605 +
    2606 +      if (dest_child) g_object_unref (dest_child);
    2607 +      dest_child = g_file_get_child (dest, g_file_info_get_name (file_info));
    2608 +
    2609 +      if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY)
    2610 +        {
    2611 +          if (!cp_internal (src_child, dest_child, mode,
    2612 +                            cancellable, error))
    2613 +            goto out;
    2614 +        }
    2615 +      else
    2616 +        {
    2617 +          gboolean did_link = FALSE;
    2618 +          (void) unlink (gs_file_get_path_cached (dest_child));
    2619 +          if (mode == GS_CP_MODE_HARDLINK)
    2620 +            {
    2621 +              if (link (gs_file_get_path_cached (src_child), gs_file_get_path_cached (dest_child)) == -1)
    2622 +                {
    2623 +                  if (!(errno == EMLINK || errno == EXDEV))
    2624 +                    {
    2625 +                      int errsv = errno;
    2626 +                      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2627 +                                           g_strerror (errsv));
    2628 +                      goto out;
    2629 +                    }
    2630 +                  /* We failed to hardlink; fall back to copying all; this will
    2631 +                   * affect subsequent directory copies too.
    2632 +                   */
    2633 +                  mode = GS_CP_MODE_COPY_ALL;
    2634 +                }
    2635 +              else
    2636 +                did_link = TRUE;
    2637 +            }
    2638 +          if (!did_link)
    2639 +            {
    2640 +              GFileCopyFlags copyflags = G_FILE_COPY_OVERWRITE | G_FILE_COPY_NOFOLLOW_SYMLINKS;
    2641 +              if (mode == GS_CP_MODE_COPY_ALL)
    2642 +                copyflags |= G_FILE_COPY_ALL_METADATA;
    2643 +              if (!g_file_copy (src_child, dest_child, copyflags,
    2644 +                                cancellable, NULL, NULL, error))
    2645 +                goto out;
    2646 +            }
    2647 +        }
    2648 +    }
    2649 +
    2650 +  ret = TRUE;
    2651 + out:
    2652 +  if (dest_dfd != -1)
    2653 +    (void) close (dest_dfd);
    2654 +  g_clear_object (&src_info);
    2655 +  g_clear_object (&enumerator);
    2656 +  g_clear_object (&dest_child);
    2657 +  return ret;
    2658 +}
    2659 +
    2660 +/**
    2661 + * gs_shutil_cp_al_or_fallback:
    2662 + * @src: Source path
    2663 + * @dest: Destination path
    2664 + * @cancellable:
    2665 + * @error:
    2666 + *
    2667 + * Recursively copy path @src (which must be a directory) to the
    2668 + * target @dest.  If possible, hardlinks are used; if a hardlink is
    2669 + * not possible, a regular copy is created.  Any existing files are
    2670 + * overwritten.
    2671 + *
    2672 + * Returns: %TRUE on success
    2673 + */
    2674 +gboolean
    2675 +gs_shutil_cp_al_or_fallback (GFile         *src,
    2676 +                             GFile         *dest,
    2677 +                             GCancellable  *cancellable,
    2678 +                             GError       **error)
    2679 +{
    2680 +  return cp_internal (src, dest, GS_CP_MODE_HARDLINK,
    2681 +                      cancellable, error);
    2682 +}
    2683 +
    2684 +/**
    2685 + * gs_shutil_cp_a:
    2686 + * @src: Source path
    2687 + * @dest: Destination path
    2688 + * @cancellable:
    2689 + * @error:
    2690 + *
    2691 + * Recursively copy path @src (which must be a directory) to the
    2692 + * target @dest.  Any existing files are overwritten.
    2693 + *
    2694 + * Returns: %TRUE on success
    2695 + */
    2696 +gboolean
    2697 +gs_shutil_cp_a (GFile         *src,
    2698 +                GFile         *dest,
    2699 +                GCancellable  *cancellable,
    2700 +                GError       **error)
    2701 +{
    2702 +  return cp_internal (src, dest, GS_CP_MODE_COPY_ALL,
    2703 +                      cancellable, error);
    2704 +}
    2705 +
    2706 +static unsigned char
    2707 +struct_stat_to_dt (struct stat *stbuf)
    2708 +{
    2709 +  if (S_ISDIR (stbuf->st_mode))
    2710 +    return DT_DIR;
    2711 +  if (S_ISREG (stbuf->st_mode))
    2712 +    return DT_REG;
    2713 +  if (S_ISCHR (stbuf->st_mode))
    2714 +    return DT_CHR;
    2715 +  if (S_ISBLK (stbuf->st_mode))
    2716 +    return DT_BLK;
    2717 +  if (S_ISFIFO (stbuf->st_mode))
    2718 +    return DT_FIFO;
    2719 +  if (S_ISLNK (stbuf->st_mode))
    2720 +    return DT_LNK;
    2721 +  if (S_ISSOCK (stbuf->st_mode))
    2722 +    return DT_SOCK;
    2723 +  return DT_UNKNOWN;
    2724 +}
    2725 +
    2726 +static gboolean
    2727 +gs_shutil_rm_rf_children (DIR                *dir,
    2728 +                          GCancellable       *cancellable,
    2729 +                          GError            **error)
    2730 +{
    2731 +  gboolean ret = FALSE;
    2732 +  int dfd;
    2733 +  DIR *child_dir = NULL;
    2734 +  struct dirent *dent;
    2735 +  union dirent_storage buf;
    2736 +
    2737 +  if (g_cancellable_set_error_if_cancelled (cancellable, error))
    2738 +    goto out;
    2739 +
    2740 +  dfd = dirfd (dir);
    2741 +
    2742 +  while (readdir_r (dir, &buf.dent, &dent) == 0)
    2743 +    {
    2744 +      if (dent == NULL)
    2745 +        break;
    2746 +      if (dent->d_type == DT_UNKNOWN)
    2747 +        {
    2748 +          struct stat stbuf;
    2749 +          if (fstatat (dfd, dent->d_name, &stbuf, AT_SYMLINK_NOFOLLOW) == -1)
    2750 +            {
    2751 +              int errsv = errno;
    2752 +              if (errsv == ENOENT)
    2753 +                continue;
    2754 +              else
    2755 +                {
    2756 +                  g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2757 +                                       g_strerror (errsv));
    2758 +                  goto out;
    2759 +                }
    2760 +            }
    2761 +          dent->d_type = struct_stat_to_dt (&stbuf);
    2762 +          /* Assume unknown types are just treated like regular files */
    2763 +          if (dent->d_type == DT_UNKNOWN)
    2764 +            dent->d_type = DT_REG;
    2765 +        }
    2766 +
    2767 +      if (strcmp (dent->d_name, ".") == 0 || strcmp (dent->d_name, "..") == 0)
    2768 +        continue;
    2769 +         
    2770 +      if (dent->d_type == DT_DIR)
    2771 +        {
    2772 +          int child_dfd = openat (dfd, dent->d_name, O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
    2773 +
    2774 +          if (child_dfd == -1)
    2775 +            {
    2776 +              if (errno == ENOENT)
    2777 +                continue;
    2778 +              else
    2779 +                {
    2780 +                  int errsv = errno;
    2781 +                  g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2782 +                                       g_strerror (errsv));
    2783 +                  goto out;
    2784 +                }
    2785 +            }
    2786 +
    2787 +          child_dir = fdopendir (child_dfd);
    2788 +          if (!child_dir)
    2789 +            {
    2790 +              int errsv = errno;
    2791 +              g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2792 +                                   g_strerror (errsv));
    2793 +              goto out;
    2794 +            }
    2795 +
    2796 +          if (!gs_shutil_rm_rf_children (child_dir, cancellable, error))
    2797 +            goto out;
    2798 +
    2799 +          if (unlinkat (dfd, dent->d_name, AT_REMOVEDIR) == -1)
    2800 +            {
    2801 +              int errsv = errno;
    2802 +              g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2803 +                                   g_strerror (errsv));
    2804 +              goto out;
    2805 +            }
    2806 +
    2807 +          (void) closedir (child_dir);
    2808 +          child_dir = NULL;
    2809 +        }
    2810 +      else
    2811 +        {
    2812 +          if (unlinkat (dfd, dent->d_name, 0) == -1)
    2813 +            {
    2814 +              int errsv = errno;
    2815 +              if (errno != ENOENT)
    2816 +                {
    2817 +                  g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2818 +                                       g_strerror (errsv));
    2819 +                  goto out;
    2820 +                }
    2821 +            }
    2822 +        }
    2823 +    }
    2824 +  /* Ignore error result from readdir_r, that's what others
    2825 +   * seem to do =(
    2826 +   */
    2827 +
    2828 +  ret = TRUE;
    2829 + out:
    2830 +  if (child_dir) (void) closedir (child_dir);
    2831 +  return ret;
    2832 +}
    2833 +
    2834 +/**
    2835 + * gs_shutil_rm_rf:
    2836 + * @path: A file or directory
    2837 + * @cancellable:
    2838 + * @error:
    2839 + *
    2840 + * Recursively delete the filename referenced by @path; it may be a
    2841 + * file or directory.  No error is thrown if @path does not exist.
    2842 + */
    2843 +gboolean
    2844 +gs_shutil_rm_rf (GFile        *path,
    2845 +                 GCancellable *cancellable,
    2846 +                 GError      **error)
    2847 +{
    2848 +  gboolean ret = FALSE;
    2849 +  int dfd = -1;
    2850 +  DIR *d = NULL;
    2851 +
    2852 +  /* With O_NOFOLLOW first */
    2853 +  dfd = openat (AT_FDCWD, gs_file_get_path_cached (path),
    2854 +                O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
    2855 +
    2856 +  if (dfd == -1)
    2857 +    {
    2858 +      int errsv = errno;
    2859 +      if (errsv == ENOENT)
    2860 +        {
    2861 +          ;
    2862 +        }
    2863 +      else if (errsv == ENOTDIR || errsv == ELOOP)
    2864 +        {
    2865 +          if (!gs_file_unlink (path, cancellable, error))
    2866 +            goto out;
    2867 +        }
    2868 +      else
    2869 +        {
    2870 +          g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2871 +                               g_strerror (errsv));
    2872 +          goto out;
    2873 +        }
    2874 +    }
    2875 +  else
    2876 +    {
    2877 +      d = fdopendir (dfd);
    2878 +      if (!d)
    2879 +        {
    2880 +          int errsv = errno;
    2881 +          g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2882 +                               g_strerror (errsv));
    2883 +          goto out;
    2884 +        }
    2885 +
    2886 +      if (!gs_shutil_rm_rf_children (d, cancellable, error))
    2887 +        goto out;
    2888 +
    2889 +      if (rmdir (gs_file_get_path_cached (path)) == -1)
    2890 +        {
    2891 +          int errsv = errno;
    2892 +          if (errsv != ENOENT)
    2893 +            {
    2894 +              g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
    2895 +                                   g_strerror (errsv));
    2896 +              goto out;
    2897 +            }
    2898 +        }
    2899 +    }
    2900 +
    2901 +  ret = TRUE;
    2902 + out:
    2903 +  if (d) (void) closedir (d);
    2904 +  return ret;
    2905 +}
    2906 +
    2907814diff -urN libgnome-desktop/libgsystem.orig/gsystem-subprocess.c libgnome-desktop/libgsystem/gsystem-subprocess.c
    2908815--- libgnome-desktop/libgsystem.orig/gsystem-subprocess.c       2014-01-15 13:06:25.000000000 -0800
  • users/devans/GNOME-3/stable/dports/gnome/gnome-themes-standard

  • users/devans/GNOME-3/stable/dports/gnome/gnome-themes-standard/Portfile

    r120413 r125662  
    66name            gnome-themes-standard
    77conflicts       gnome-themes
    8 version         3.12.0
     8version         3.14.0
    99set branch      [join [lrange [split ${version} .] 0 1] .]
    1010categories      gnome
     
    2424use_xz          yes
    2525
    26 checksums       rmd160  261021d7df4dc1745db9ded24e709362cb3a81ae \
    27                 sha256  a05d1b7ca872b944a69d0c0cc2369408ece32ff4355e37f8594a1b70d13c3217
     26checksums       rmd160  48d8695cf7f45ad9918cdca6a7de7379255c72c5 \
     27                sha256  addd469f4ba746f8ebb03da8b5c67b7d8b6b2c979f7f07958455c7e33fbdbe09
    2828
    2929depends_build   port:intltool \
     
    3232depends_lib     port:gtk3 \
    3333                port:gtk2 \
    34                 port:librsvg
     34                port:librsvg \
     35                port:adwaita-icon-theme \
     36                port:gnome-backgrounds
    3537
    3638# update m4/intltool.m4 and autoreconf
     
    4547configure.args  --disable-silent-rules
    4648
    47 notes "
    48 You can make Adwaita the default theme with:
    49 ------------------------------------------------------
    50 mkdir -p ~/.config/gtk-3.0 &&
    51 cat > ~/.config/gtk-3.0/settings.ini << \"EOF\"
    52 \[Settings\]
    53 gtk-theme-name = Adwaita
    54 gtk-fallback-icon-theme = gnome
    55 EOF
    56 ------------------------------------------------------
    57 "
    58 
    5949livecheck.type  gnome
  • users/devans/GNOME-3/stable/dports/gnome/gsettings-desktop-schemas

  • users/devans/GNOME-3/stable/dports/gnome/gsettings-desktop-schemas/Portfile

    r120018 r125662  
    55
    66name            gsettings-desktop-schemas
    7 version         3.12.2
     7version         3.14.0
    88license         LGPL-2.1
    99set branch      [join [lrange [split ${version} .] 0 1] .]
     
    2323use_xz          yes
    2424
    25 checksums       rmd160  c693dfbf24993b0220a10e1ec82bf2cec6d9bab2 \
    26                 sha256  da75021e9c45a60d0a97ea3486f93444275d0ace86dbd1b97e5d09000d8c4ad1
     25checksums       rmd160  f8103bc46fc04f031ed1cffda2ca07012e731a04 \
     26                sha256  cf3ba58f6257155080b1872b4a6ce4a2424bb7af3f08e607b428cb47b065f2d7
    2727
    2828supported_archs noarch
  • users/devans/GNOME-3/stable/dports/gnome/gtk3

  • users/devans/GNOME-3/stable/dports/gnome/gtk3/Portfile

    r120529 r125662  
    1111set real_name       gtk+
    1212epoch               1
    13 version             3.12.2
     13version             3.14.0
    1414set branch          [join [lrange [split ${version} .] 0 1] .]
    1515categories          gnome x11
     
    1818platforms           darwin
    1919
    20 checksums           rmd160  49dd0b66a3f0806106f958949a8c655494882fad \
    21                     sha256  61d74eea74231b1ea4b53084a9d6fc9917ab0e1d71b69d92cbf60a4b4fb385d0
     20checksums           rmd160  7bba8619b20b8a76794b4539b0da4cfb59483361 \
     21                    sha256  68d6b57d15c16808d0045e96b303f3dd439cc22a9c06fdffb07025cd713a82bc
    2222
    2323description         GTK+ widget toolkit
  • users/devans/GNOME-3/stable/dports/gnome/libgdata

  • users/devans/GNOME-3/stable/dports/gnome/libgdata/Portfile

    r123547 r125662  
    55
    66name            libgdata
    7 version         0.15.2
     7version         0.16.0
    88set branch      [join [lrange [split ${version} .] 0 1] .]
    99description     libgdata is a GLib-based library for accessing online service APIs using the \
     
    2323use_xz          yes
    2424
    25 checksums       rmd160  4832dadaa66d01abe124875244ca14cfc5dd313e \
    26                 sha256  fb70ab60d355edabb05cb82737f322111496b835a0db9e03acee6425891cfd0c
     25checksums       rmd160  a9d48c6840eb554b4dd989e46c21fa2bffc6d994 \
     26                sha256  66bc279ff8fbebb8eb2602d33e37e3140747ba1e4dc1f1b944c0f312f00ab479
    2727
    2828depends_build   port:pkgconfig \
  • users/devans/GNOME-3/stable/dports/gnome/libgdata/files/patch-gdata-gdata.symbols.diff

    r120444 r125662  
    1 --- gdata/gdata.symbols.orig    2014-05-28 08:19:19.000000000 -0700
    2 +++ gdata/gdata.symbols 2014-05-28 08:20:24.000000000 -0700
    3 @@ -1087,8 +1087,6 @@
     1--- gdata/gdata.symbols.orig    2014-09-17 16:22:31.000000000 -0700
     2+++ gdata/gdata.symbols 2014-09-19 00:22:07.000000000 -0700
     3@@ -1089,8 +1089,6 @@
    44 gdata_freebase_topic_result_get_type
    55 gdata_freebase_topic_result_new
  • users/devans/GNOME-3/stable/dports/gnome/libsoup

  • users/devans/GNOME-3/stable/dports/gnome/libsoup/Portfile

    r120529 r125662  
    55
    66name            libsoup
    7 version         2.46.0
     7version         2.48.0
    88set branch      [join [lrange [split ${version} .] 0 1] .]
    99categories      gnome net
     
    2525use_xz          yes
    2626
    27 checksums       rmd160  65b02b7fa6e0f2ce7d2127f13196ba66017d3c9f \
    28                 sha256  fa3d5574c1a2df521242e2ca624a2b3057121798cab9f8f40525aa186a7b15a3
     27checksums       rmd160  534882e8b5b26ad5f5a232c63813dbff5336303c \
     28                sha256  ea34dd64fe44343445daf6dd690d0691e9d973468de44878da97371c16d89784
    2929
    3030depends_build   port:pkgconfig \
     
    3434                port:glib-networking \
    3535                port:gobject-introspection
     36
     37patchfiles      patch-libsoup-libsoup-2.4.sym.diff
    3638
    3739configure.args \
  • users/devans/GNOME-3/stable/dports/lang/vala

  • users/devans/GNOME-3/stable/dports/lang/vala/Portfile

    r118520 r125662  
    55
    66name                vala
    7 version             0.24.0
     7version             0.26.0
    88set branch          [join [lrange [split ${version} .] 0 1] .]
    99categories          lang
     
    2424use_xz              yes
    2525
    26 checksums           rmd160  dd078fe42dc502b9c700eadc2d79f4dde541fb69 \
    27                     sha256  22a37c977512c19cd29c373eaaef96cb2c994795d491106f32387f3f9d1e899c
     26checksums           rmd160  816a9f2a90418cfd200eb47b759e9572fa5a7b04 \
     27                    sha256  c1d0a6a485d5cbfbe027483adfc5f7c80c2404b692375be80d75193d915dcd2f
    2828
    2929depends_build       path:bin/pkg-config:pkgconfig \
     
    3232depends_lib         path:lib/pkgconfig/glib-2.0.pc:glib2
    3333
    34 configure.args      --enable-vapigen
    35 
    3634livecheck.type      gnome
  • users/devans/GNOME-3/stable/dports/python/py-gobject3

  • users/devans/GNOME-3/stable/dports/python/py-gobject3/Portfile

    r125521 r125662  
    77name                py-gobject3
    88set my_name         pygobject
    9 version             3.13.92
     9version             3.14.0
    1010set branch          [join [lrange [split ${version} .] 0 1] .]
    1111categories-append   gnome
     
    2424use_xz              yes
    2525
    26 checksums           sha256  4a405fb49afa357de6cc4138a47c509ae2a5e2e5aff7d5245b22bc8e3bd4c347 \
    27                     rmd160  c8447c2cbdf3e2ec31ba8f165ff7d923fece5bca
     26checksums           sha256  779effa93f4b59cdb72f4ab0128fb3fd82900bf686193b570fd3a8ce63392d54 \
     27                    rmd160  9d8c217252798a38ac9420285dbb2b50080f749d
    2828
    2929python.versions     27 32 33 34
     
    3838    use_configure           yes
    3939    configure.python        ${python.bin}
    40     configure.env-append    PKG_CONFIG_PATH='${python.prefix}/lib/pkgconfig'
     40    configure.pkg_config_path \
     41                            ${python.prefix}/lib/pkgconfig
    4142    configure.pre_args      --prefix='${python.prefix}'
    4243    configure.args          --disable-glibtest \
     
    6667    livecheck.type  none
    6768} else {
    68     livecheck.type  gnome-with-unstable
     69    livecheck.type  gnome
    6970    livecheck.name  ${my_name}
    7071}
  • users/devans/GNOME-3/stable/dports/x11/gtkmm3

  • users/devans/GNOME-3/stable/dports/x11/gtkmm3/Portfile

    r119139 r125662  
    77name            gtkmm3
    88set gname       gtkmm
    9 version         3.12.0
     9version         3.14.0
    1010set branch      [join [lrange [split ${version} .] 0 1] .]
    1111description     C++ interface to GTK+ version 3.
     
    2525distname        ${gname}-${version}
    2626
    27 checksums       rmd160  e16dd67bd02c6e7adf13de1578e63ca33cf547b6 \
    28                 sha256  86c526ceec15d889996822128d566748bb36f70cf5a2c270530dfc546a2574e1
     27checksums       rmd160  49e5fae69ecedeb37caf7dba1b89748fa56debb3 \
     28                sha256  d9f528a62c6ec226fa08287c45c7465b2dce5aae5068e9ac48d30a64a378e48b
    2929
    3030depends_build   port:pkgconfig \
Note: See TracChangeset for help on using the changeset viewer.