LCOV - code coverage report
Current view: top level - glib - gutilsprivate.c (source / functions) Coverage Total Hit
Test: unnamed Lines: 86.8 % 68 59
Test Date: 2026-01-13 05:17:23 Functions: 100.0 % 1 1
Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* adapted from xdg-user-dir-lookup.c
       2                 :             :  *
       3                 :             :  * Copyright (C) 2007 Red Hat Inc.
       4                 :             :  *
       5                 :             :  * Permission is hereby granted, free of charge, to any person
       6                 :             :  * obtaining a copy of this software and associated documentation files
       7                 :             :  * (the "Software"), to deal in the Software without restriction,
       8                 :             :  * including without limitation the rights to use, copy, modify, merge,
       9                 :             :  * publish, distribute, sublicense, and/or sell copies of the Software,
      10                 :             :  * and to permit persons to whom the Software is furnished to do so,
      11                 :             :  * subject to the following conditions:
      12                 :             :  *
      13                 :             :  * The above copyright notice and this permission notice shall be
      14                 :             :  * included in all copies or substantial portions of the Software.
      15                 :             :  *
      16                 :             :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      17                 :             :  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      18                 :             :  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      19                 :             :  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
      20                 :             :  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
      21                 :             :  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
      22                 :             :  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
      23                 :             :  * SOFTWARE.
      24                 :             :  */
      25                 :             : static void
      26                 :          19 : load_user_special_dirs_from_string (const gchar *string, const gchar *home_dir, gchar **special_dirs)
      27                 :             : {
      28                 :             :   gchar **lines;
      29                 :             :   gint n_lines, i;
      30                 :             :   size_t min_len;
      31                 :             : 
      32                 :          19 :   lines = g_strsplit (string, "\n", -1);
      33                 :          19 :   n_lines = g_strv_length (lines);
      34                 :             : 
      35                 :         179 :   for (i = 0; i < n_lines; i++)
      36                 :             :     {
      37                 :         160 :       gchar *buffer = lines[i];
      38                 :             :       gchar *d, *p;
      39                 :             :       size_t len;
      40                 :         160 :       gboolean is_relative = FALSE;
      41                 :             :       GUserDirectory directory;
      42                 :             : 
      43                 :             :       /* Remove newline at end */
      44                 :         160 :       len = strlen (buffer);
      45                 :         160 :       if (len > 0 && buffer[len - 1] == '\n')
      46                 :           0 :         buffer[len - 1] = 0;
      47                 :             : 
      48                 :         160 :       p = buffer;
      49                 :         160 :       while (*p == ' ' || *p == '\t')
      50                 :           0 :         p++;
      51                 :             : 
      52                 :         160 :       if (strncmp (p, "XDG_DESKTOP_DIR", strlen ("XDG_DESKTOP_DIR")) == 0)
      53                 :             :         {
      54                 :          24 :           directory = G_USER_DIRECTORY_DESKTOP;
      55                 :          24 :           p += strlen ("XDG_DESKTOP_DIR");
      56                 :             :         }
      57                 :         136 :       else if (strncmp (p, "XDG_DOCUMENTS_DIR", strlen ("XDG_DOCUMENTS_DIR")) == 0)
      58                 :             :         {
      59                 :          18 :           directory = G_USER_DIRECTORY_DOCUMENTS;
      60                 :          18 :           p += strlen ("XDG_DOCUMENTS_DIR");
      61                 :             :         }
      62                 :         118 :       else if (strncmp (p, "XDG_DOWNLOAD_DIR", strlen ("XDG_DOWNLOAD_DIR")) == 0)
      63                 :             :         {
      64                 :          18 :           directory = G_USER_DIRECTORY_DOWNLOAD;
      65                 :          18 :           p += strlen ("XDG_DOWNLOAD_DIR");
      66                 :             :         }
      67                 :         100 :       else if (strncmp (p, "XDG_MUSIC_DIR", strlen ("XDG_MUSIC_DIR")) == 0)
      68                 :             :         {
      69                 :          12 :           directory = G_USER_DIRECTORY_MUSIC;
      70                 :          12 :           p += strlen ("XDG_MUSIC_DIR");
      71                 :             :         }
      72                 :          88 :       else if (strncmp (p, "XDG_PICTURES_DIR", strlen ("XDG_PICTURES_DIR")) == 0)
      73                 :             :         {
      74                 :          12 :           directory = G_USER_DIRECTORY_PICTURES;
      75                 :          12 :           p += strlen ("XDG_PICTURES_DIR");
      76                 :             :         }
      77                 :          76 :       else if (strncmp (p, "XDG_PUBLICSHARE_DIR", strlen ("XDG_PUBLICSHARE_DIR")) == 0)
      78                 :             :         {
      79                 :           6 :           directory = G_USER_DIRECTORY_PUBLIC_SHARE;
      80                 :           6 :           p += strlen ("XDG_PUBLICSHARE_DIR");
      81                 :             :         }
      82                 :          70 :       else if (strncmp (p, "XDG_TEMPLATES_DIR", strlen ("XDG_TEMPLATES_DIR")) == 0)
      83                 :             :         {
      84                 :           0 :           directory = G_USER_DIRECTORY_TEMPLATES;
      85                 :           0 :           p += strlen ("XDG_TEMPLATES_DIR");
      86                 :             :         }
      87                 :          70 :       else if (strncmp (p, "XDG_VIDEOS_DIR", strlen ("XDG_VIDEOS_DIR")) == 0)
      88                 :             :         {
      89                 :           0 :           directory = G_USER_DIRECTORY_VIDEOS;
      90                 :           0 :           p += strlen ("XDG_VIDEOS_DIR");
      91                 :             :         }
      92                 :             :       else
      93                 :          70 :         continue;
      94                 :             : 
      95                 :         180 :       while (*p == ' ' || *p == '\t')
      96                 :          90 :         p++;
      97                 :             : 
      98                 :          90 :       if (*p != '=')
      99                 :           0 :         continue;
     100                 :          90 :       p++;
     101                 :             : 
     102                 :         180 :       while (*p == ' ' || *p == '\t')
     103                 :          90 :         p++;
     104                 :             : 
     105                 :          90 :       if (*p != '"')
     106                 :           0 :         continue;
     107                 :          90 :       p++;
     108                 :             : 
     109                 :          90 :       if (strncmp (p, "$HOME", 5) == 0)
     110                 :             :         {
     111                 :          30 :           p += 5;
     112                 :          30 :           if (*p != '/' && *p != '"')
     113                 :           6 :             continue;
     114                 :          24 :           is_relative = TRUE;
     115                 :             :         }
     116                 :          60 :       else if (*p != '/')
     117                 :           0 :         continue;
     118                 :             : 
     119                 :          84 :       d = strrchr (p, '"');
     120                 :          84 :       if (d < p)
     121                 :           6 :         continue;
     122                 :          78 :       *d = 0;
     123                 :             : 
     124                 :          78 :       d = p;
     125                 :             : 
     126                 :             :       /* remove trailing slashes, but keep first slash in absolute path */
     127                 :          78 :       min_len = is_relative ? 0 : 1;
     128                 :          96 :       for (len = strlen (d); len > min_len && d[len - 1] == '/'; len--)
     129                 :          18 :         d[len - 1] = 0;
     130                 :             : 
     131                 :             :       /* Duplicates override the previous value. This is not explicit in the
     132                 :             :        * spec, but given that the spec[1] is designed to allow user-dirs.dirs to
     133                 :             :        * be sourced in a shell, overriding is the behaviour that would imply.
     134                 :             :        *
     135                 :             :        * [1]: https://www.freedesktop.org/wiki/Software/xdg-user-dirs/ */
     136                 :          78 :       g_clear_pointer (&special_dirs[directory], g_free);
     137                 :             : 
     138                 :          78 :       if (is_relative)
     139                 :          24 :         special_dirs[directory] = g_build_filename (home_dir, d, NULL);
     140                 :             :       else
     141                 :         108 :         special_dirs[directory] = g_strdup (d);
     142                 :             :     }
     143                 :             : 
     144                 :          19 :   g_strfreev (lines);
     145                 :          19 : }
        

Generated by: LCOV version 2.0-1