dlls/shell32/xdg.c

   1 /*
   2  * Generic freedesktop.org support code
   3  *
   4  * Copyright (C) 2006 Mikolaj Zalewski
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  *
  21  * XDG_UserDirLookup() and helper functions are based on code from:
  22  * http://www.freedesktop.org/wiki/Software/xdg-user-dirs
  23  *
  24  * Copyright (c) 2007 Red Hat, inc
  25  *
  26  * From the xdg-user-dirs license:
  27  * Permission is hereby granted, free of charge, to any person
  28  * obtaining a copy of this software and associated documentation files
  29  * (the "Software"), to deal in the Software without restriction,
  30  * including without limitation the rights to use, copy, modify, merge,
  31  * publish, distribute, sublicense, and/or sell copies of the Software,
  32  * and to permit persons to whom the Software is furnished to do so,
  33  * subject to the following conditions:
  34  *
  35  * The above copyright notice and this permission notice shall be
  36  * included in all copies or substantial portions of the Software.
  37  *
  38  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  39  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  40  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  41  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  42  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  43  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  44  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  45  * SOFTWARE.
  46  */
  47
  48 #include "config.h"
  49 #include "wine/port.h"
  50
  51 #include <stdio.h>
  52 #include <stdarg.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55 #ifdef HAVE_SYS_STAT_H
  56 # include <sys/stat.h>
  57 #endif
  58 #ifdef HAVE_UNISTD_H
  59 # include <unistd.h>
  60 #endif
  61 #include <errno.h>
  62
  63 #include "windef.h"
  64 #include "winbase.h"
  65 #include "winreg.h"
  66 #include "shlwapi.h"
  67 #include "wine/debug.h"
  68 #include "shell32_main.h"
  69 #include "xdg.h"
  70
  71 WINE_DEFAULT_DEBUG_CHANNEL(xdg);
  72
  73 /*
  74  * XDG paths implemented using Desktop Base Directory spec version 0.6
  75  * (from http://standards.freedesktop.org/basedir-spec/basedir-spec-0.6.html)
  76  */
  77
  78 static CRITICAL_SECTION XDG_PathsLock;
  79 static CRITICAL_SECTION_DEBUG XDG_PathsLock_Debug =
  80 {
  81     0, 0, &XDG_PathsLock,
  82     { &XDG_PathsLock_Debug.ProcessLocksList,
  83       &XDG_PathsLock_Debug.ProcessLocksList},
  84     0, 0, { (DWORD_PTR)__FILE__ ": XDG_PathsLock"}
  85 };
  86 static CRITICAL_SECTION XDG_PathsLock = { &XDG_PathsLock_Debug, -1, 0, 0, 0, 0 };
  87
  88 typedef struct
  89 {
  90     const char *var_name;
  91     const char *default_value;
  92 } std_path;
  93
  94 static const std_path paths[] = {
  95     {"XDG_DATA_HOME", "$HOME/.local/share"},
  96     {"XDG_CONFIG_HOME", "$HOME/.config"},
  97     {"XDG_DATA_DIRS", "/usr/local/share:/usr/share"},
  98     {"XDG_CONFIG_DIRS", "/etc/xdg"},
  99     {"XDG_CACHE_HOME", "$HOME/.cache"}
 100 };
 101
 102 #define PATHS_COUNT (sizeof(paths)/sizeof(paths[0]))
 103
 104 /* will be filled with paths as they are computed */
 105 static const char *path_values[PATHS_COUNT] = {
 106     NULL,
 107     NULL,
 108     NULL,
 109     NULL,
 110     NULL
 111 };
 112
 113 static char *load_path(int path_id)
 114 {
 115     char *env = getenv(paths[path_id].var_name);
 116     char *ret;
 117
 118     if (env != NULL && env[0]=='/')
 119     {
 120         ret = SHAlloc(strlen(env)+1);
 121         if (ret != NULL)
 122             lstrcpyA(ret, env);
 123         return ret;
 124     }
 125
 126     if (memcmp(paths[path_id].default_value, "$HOME", 5)==0)
 127     {
 128         char *home = getenv("HOME");
 129         int len;
 130
 131         if (!home) return NULL;
 132         ret = SHAlloc(strlen(home)+strlen(paths[path_id].default_value)-5+1);
 133         if (ret == NULL) return NULL;
 134
 135         lstrcpyA(ret, home);
 136         len = strlen(ret);
 137         if (len>0 && ret[len-1]=='/')
 138             ret[--len]=0;
 139         lstrcatA(ret, paths[path_id].default_value+5);
 140         return ret;
 141     }
 142
 143     ret = SHAlloc(strlen(paths[path_id].default_value)+1);
 144     if (ret != NULL)
 145         lstrcpyA(ret, paths[path_id].default_value);
 146     return ret;
 147 }
 148
 149 /******************************************************************************
 150  * XDG_GetPath    [internal]
 151  *
 152  * Get one of the XDG standard patch. The return value shouldn't be modified nor
 153  * freed. A return value of NULL means that the memory is exhausted or the input
 154  * is invalid
 155  *
 156  * For XDG_DATA_HOME, XDG_CONFIG_HOME and XDG_CACHE_HOME the result is a Unix path.
 157  * For XDG_DATA_DIRS and XDG_CONFIG_DIRS the result is a colon-separated list of Unix
 158  * paths
 159  *
 160  * The paths are guaranteed to start with '/'
 161  */
 162 static const char *XDG_GetPath(int path_id)
 163 {
 164     if (path_id >= PATHS_COUNT || path_id < 0)
 165     {
 166         ERR("Invalid path_id %d\n", path_id);
 167         return NULL;
 168     }
 169
 170     if (path_values[path_id] != NULL)
 171         return path_values[path_id];
 172     EnterCriticalSection(&XDG_PathsLock);
 173     if (path_values[path_id] == NULL)
 174         path_values[path_id] = load_path(path_id);
 175     LeaveCriticalSection(&XDG_PathsLock);
 176     return path_values[path_id];
 177 }
 178
 179 /******************************************************************************
 180  * XDG_BuildPath    [internal]
 181  *
 182  * Build a string with a subpath of one of the XDG standard paths.
 183  * The root can be one of XDG_DATA_HOME, XDG_CONFIG_HOME and XDG_CACHE_HOME.
 184  * The subpath is a path relative to that root (it shouldn't start with a slash)
 185  *
 186  * The returned path should be freed with SHFree. A return of NULL means that the
 187  * memory is exhausted or the parameters are invalid
 188  */
 189 char *XDG_BuildPath(int root_id, const char *subpath)
 190 {
 191     const char *root_path = XDG_GetPath(root_id);
 192     char *ret_buffer;
 193     int root_len;
 194
 195     if (root_id == XDG_DATA_DIRS || root_id == XDG_CONFIG_DIRS)
 196     {
 197         ERR("Invalid path id %d\n", root_id);
 198         return NULL;
 199     }
 200
 201     if (root_path == NULL) return NULL;
 202     root_len = strlen(root_path);
 203     if (root_path[root_len-1]=='/') root_len--;
 204     ret_buffer = SHAlloc(root_len+1+strlen(subpath)+1);
 205     if (ret_buffer == NULL) return NULL;
 206     lstrcpyA(ret_buffer, root_path);
 207     ret_buffer[root_len]='/';
 208     lstrcpyA(ret_buffer+root_len+1, subpath);
 209     return ret_buffer;
 210 }
 211
 212 /******************************************************************************
 213  * XDG_MakeDirs    [internal]
 214  *
 215  * Checks that all the directories on the specified path exists. If some don't exists
 216  * they are created with mask 0700 as required by many the freedeskop.org specs.
 217  * If the path doesn't end with '/' it is assumed to be a path to a file and the last
 218  * segment is not checked
 219  *
 220  * In case of a failure the errno is always set and can be used e.g for debugging
 221  *
 222  * RETURNS
 223  *   TRUE on success, FALSE on error
 224  */
 225 BOOL XDG_MakeDirs(const char *path)
 226 {
 227     int last_slash = 0;
 228     BOOL success = TRUE;
 229     struct stat tmp;
 230     char *buffer = SHAlloc(strlen(path)+1);
 231
 232     if (buffer == NULL)
 233     {
 234         errno = ENOMEM;
 235         return FALSE;
 236     }
 237     lstrcpyA(buffer, path);
 238
 239     TRACE("(%s)\n", debugstr_a(path));
 240     while (1)
 241     {
 242         char *slash=strchr(buffer+last_slash+1, '/');
 243         if (slash==NULL)
 244             break;
 245
 246         /* cut the string at that position and create the directory if it doesn't exist */
 247         *slash=0;
 248         TRACE("Checking path %s\n", debugstr_a(buffer));
 249         success = (stat(buffer, &tmp)==0);
 250         if (!success && errno==ENOENT)
 251         {
 252             TRACE("Creating\n");
 253             success = (mkdir(buffer, 0700)==0);
 254         }
 255         if (!success)
 256         {
 257             WARN("Couldn't process directory %s (errno=%d)\n", debugstr_a(buffer), errno);
 258             break;
 259         }
 260         *slash='/';
 261         last_slash = slash-buffer;
 262     }
 263     SHFree(buffer);
 264     return success;
 265 }
 266
 267 /*
 268  * .desktop files functions
 269  */
 270
 271
 272 /******************************************************************************
 273  * dskentry_encode    [internal]
 274  *
 275  * Escape the characters that can't be present in a desktop entry value like \n, leading
 276  * spaces etc. The output parameter may be NULL. Then only the number of characters will
 277  * be computers.
 278  *
 279  * RETURNS
 280  *   The number of characters after escaping the special characters, including the
 281  * terminating NUL.
 282  */
 283 static int dskentry_encode(const char *value, char *output)
 284 {
 285     BOOL only_spc = TRUE;
 286     int num_written = 0;
 287     const char *c;
 288     for (c = value; *c; c++)
 289     {
 290         if (only_spc && *c==' ')
 291         {
 292             if (output)
 293             {
 294                 *(output++) = '\\';
 295                 *(output++) = 's';
 296             }
 297             num_written += 2;
 298             continue;
 299         }
 300         only_spc = FALSE;
 301
 302         if (*c=='\t' || *c=='\r' || *c=='\n' || *c=='\\')
 303         {
 304             if (output)
 305             {
 306                 *(output++) = '\\';
 307                 if (*c=='\t') *(output++) = 't';
 308                 if (*c=='\r') *(output++) = 'r';
 309                 if (*c=='\n') *(output++) = 'n';
 310                 if (*c=='\\') *(output++) = '\\';
 311             }
 312             num_written += 2;
 313         }
 314         else
 315         {
 316             if (output)
 317                 *(output++)=*c;
 318             num_written++;
 319         }
 320     }
 321
 322     if (output)
 323         *(output++) = 0;
 324     num_written++;
 325     return num_written;
 326 }
 327
 328 /******************************************************************************
 329  * dskentry_decode    [internal]
 330  *
 331  * Unescape the characters that can be escaped according to the desktop entry spec.
 332  * The output parameter may be NULL. Then only the number of characters will
 333  * be computers.
 334  *
 335  * RETURNS
 336  *   The number of characters after unescaping the special characters, including the
 337  * terminating NUL.
 338  */
 339 static int dskentry_decode(const char *value, int len, char *output)
 340 {
 341     int pos = 0;
 342     int count = 0;
 343     while (pos<len)
 344     {
 345         char c;
 346         if (value[pos] == '\\' && pos<len-1)
 347         {
 348             pos++;
 349             switch (value[pos])
 350             {
 351                 case 's': c = ' '; break;
 352                 case 'n': c = '\n'; break;
 353                 case 't': c = '\t'; break;
 354                 case 'r': c = 'r'; break;
 355                 case '\\': c = '\\'; break;
 356                 default:
 357                     /* store both the backslash and the character */
 358                     if (output)
 359                         *(output++) = '\\';
 360                     count++;
 361                     c = value[pos];
 362                     break;
 363             }
 364         }
 365         else
 366             c = value[pos];
 367
 368         if (output)
 369             *(output++) = c;
 370         count++;
 371         pos++;
 372     }
 373
 374     if (output)
 375         *(output++) = 0;
 376     count++;
 377     return count;
 378 }
 379
 380
 381 /******************************************************************************
 382  * url_encode    [internal]
 383  *
 384  * URL-encode the given string (i.e. use escape codes like %20). Note that an
 385  * URL-encoded string can be used as a value in desktop entry files as all
 386  * unsafe characters are escaped.
 387  *
 388  * The output can be NULL. Then only the number of characters will be counted
 389  *
 390  * RETURNS
 391  *   The number of characters after escaping the special characters, including the
 392  * terminating NUL.
 393  */
 394 static int url_encode(const char *value, char *output)
 395 {
 396     static const char unsafechars[] = "^&`{}|[]'<>\\#%\"+";
 397     static const char hexchars[] = "0123456789ABCDEF";
 398     int num_written = 0;
 399     const char *c;
 400
 401     for (c = value; *c; c++)
 402     {
 403         if (*c<=0x20 || *c>=0x7f || strchr(unsafechars, *c))
 404         {
 405             if (output)
 406             {
 407                 *(output++) = '%';
 408                 *(output++) = hexchars[(unsigned char)*c / 16];
 409                 *(output++) = hexchars[(unsigned char)*c % 16];
 410             }
 411             num_written += 3;
 412         }
 413         else
 414         {
 415             if (output)
 416                 *(output++) = *c;
 417             num_written++;
 418         }
 419     }
 420
 421     if (output)
 422         *(output++) = 0;
 423     num_written++;
 424
 425     return num_written;
 426 }
 427
 428 static int decode_url_code(const char *c)
 429 {
 430     const char *p1, *p2;
 431     int v1, v2;
 432     static const char hexchars[] = "0123456789ABCDEF";
 433     if (*c == 0)
 434         return -1;
 435
 436     p1 = strchr(hexchars, toupper(*c));
 437     p2 = strchr(hexchars, toupper(*(c+1)));
 438     if (p1 == NULL || p2 == NULL)
 439         return -1;
 440     v1 = (int)(p1 - hexchars);
 441     v2 = (int)(p2 - hexchars);
 442     return (v1<<4) + v2;
 443 }
 444
 445 /******************************************************************************
 446  * url_decode    [internal]
 447  *
 448  * URL-decode the given string (i.e. unescape codes like %20). The decoded string
 449  * will never be longer than the encoded one. The decoding can be done in place - the
 450  * output variable can point to the value buffer.
 451  *
 452  * output should not be NULL
 453  */
 454 static void url_decode(const char *value, char *output)
 455 {
 456     const char *c = value;
 457     while (*c)
 458     {
 459         if (*c == '%')
 460         {
 461             int v = decode_url_code(c+1);
 462             if (v != -1)
 463             {
 464                 *(output++) = v;
 465                 c += 3;
 466                 continue;
 467             }
 468         }
 469
 470         *(output++) = *c;
 471         c++;
 472     }
 473     *output = 0;
 474 }
 475
 476 static int escape_value(const char *value, DWORD dwFlags, char *output)
 477 {
 478     if (dwFlags & XDG_URLENCODE)
 479         return url_encode(value, output);
 480     return dskentry_encode(value, output);
 481 }
 482
 483 /******************************************************************************
 484  * XDG_WriteDesktopStringEntry    [internal]
 485  *
 486  * Writes a key=value pair into the specified file descriptor.
 487  *
 488  * RETURNS
 489  *   TRUE on success, else FALSE
 490  */
 491 BOOL XDG_WriteDesktopStringEntry(int writer, const char *keyName, DWORD dwFlags, const char *value)
 492 {
 493     int keyLen = lstrlenA(keyName);
 494     int valueLen = escape_value(value, dwFlags, NULL);
 495     char *string = SHAlloc(keyLen+1+valueLen);
 496     BOOL ret;
 497
 498     if (string == NULL)
 499         return FALSE;
 500     lstrcpyA(string, keyName);
 501     string[keyLen] = '=';
 502     escape_value(value, dwFlags, string+keyLen+1);
 503     string[keyLen+1+valueLen-1]='\n';   /* -1 because valueLen contains the last NUL character */
 504     ret = (write(writer, string, keyLen+1+valueLen)!=-1);
 505     SHFree(string);
 506     return ret;
 507 }
 508
 509 typedef struct
 510 {
 511     char *str;
 512     int len;
 513 } PARSED_STRING;
 514
 515 typedef struct tagPARSED_ENTRY PARSED_ENTRY;
 516 struct tagPARSED_ENTRY
 517 {
 518     PARSED_STRING name;
 519     PARSED_STRING equals;
 520     PARSED_STRING value;
 521     PARSED_ENTRY *next;
 522 };
 523
 524 typedef struct tagPARSED_GROUP PARSED_GROUP;
 525 struct tagPARSED_GROUP
 526 {
 527     PARSED_STRING name;
 528     PARSED_ENTRY *entries;
 529     PARSED_GROUP *next;
 530 };
 531
 532
 533 struct tagXDG_PARSED_FILE
 534 {
 535     char *contents;
 536     PARSED_ENTRY *head_comments;
 537     PARSED_GROUP *groups;
 538 };
 539
 540 static BOOL parsed_str_eq(const PARSED_STRING *str1, const char *str2)
 541 {
 542     if (strncmp(str1->str, str2, str1->len) != 0)
 543         return FALSE;
 544     if (str2[str1->len] != 0)
 545         return FALSE;
 546     return TRUE;
 547 }
 548
 549 static void free_entries_list(PARSED_ENTRY *first)
 550 {
 551     PARSED_ENTRY *next;
 552     while (first)
 553     {
 554         next = first->next;
 555         SHFree(first);
 556         first = next;
 557     }
 558 }
 559
 560 void XDG_FreeParsedFile(XDG_PARSED_FILE *parsed)
 561 {
 562     PARSED_GROUP *group, *next;
 563     if (!parsed)
 564         return;
 565     free_entries_list(parsed->head_comments);
 566
 567     group = parsed->groups;
 568     while (group)
 569     {
 570         next = group->next;
 571         free_entries_list(group->entries);
 572         SHFree(group);
 573         group = next;
 574     }
 575     SHFree(parsed->contents);
 576     SHFree(parsed);
 577 }
 578
 579 #define LINE_GROUP   1
 580 #define LINE_ENTRY   2
 581 #define LINE_COMMENT 3
 582
 583 static int parse_line(char *content, PARSED_ENTRY *output, int *outType)
 584 {
 585     char *end;
 586
 587     ZeroMemory(output, sizeof(PARSED_ENTRY));
 588     end = strchr(content, '\n');
 589     if (end == NULL)
 590         end = content + strlen(content) - 1;
 591
 592     if (*content == '#')
 593     {
 594         *outType = LINE_COMMENT;
 595         output->equals.str = content;
 596         output->equals.len = end - content;
 597         if (*end != '\n')
 598             output->equals.len++;
 599     }
 600     else if (*content == '[')
 601     {
 602         char *last_char = end;
 603
 604         *outType = LINE_GROUP;
 605
 606         /* the standard says nothing about skipping white spaces but e.g. KDE accepts such files */
 607         while (isspace(*last_char))
 608             last_char--;
 609         if (*last_char != ']')
 610             return -1;
 611         output->name.str = content + 1;
 612         output->name.len = last_char - (content + 1);
 613     }
 614     else
 615     {
 616         /* 'name = value' line */
 617         char *equal, *eq_begin, *eq_end;
 618
 619         *outType = LINE_ENTRY;
 620
 621         equal = strchr(content, '=');
 622         if (equal == NULL || equal > end)
 623             return -1;
 624         for (eq_begin = equal-1;  isspace(*eq_begin) && eq_begin >= content; eq_begin--)
 625             ;
 626         for (eq_end = equal+1; isspace(*eq_end) && *eq_end != '\n'; eq_end++)
 627             ;
 628
 629         output->name.str = content;
 630         output->name.len = eq_begin - content + 1;
 631
 632         output->equals.str = eq_begin + 1;
 633         output->equals.len = eq_end - eq_begin - 1;
 634
 635         output->value.str = eq_end;
 636         output->value.len = end - eq_end;
 637
 638         if (*end != '\n')
 639             output->value.len++;
 640     }
 641     return end - content + 1;
 642 }
 643
 644 XDG_PARSED_FILE *XDG_ParseDesktopFile(int fd)
 645 {
 646     struct stat stats;
 647     XDG_PARSED_FILE *parsed = NULL;
 648     PARSED_ENTRY **curr_entry;
 649     PARSED_GROUP **curr_group;
 650     BOOL is_in_group = FALSE;
 651
 652     int pos = 0;
 653
 654     if (fstat(fd, &stats) == -1) goto failed;
 655     parsed = SHAlloc(sizeof(XDG_PARSED_FILE));
 656     if (parsed == NULL) goto failed;
 657     parsed->groups = NULL;
 658     parsed->head_comments = NULL;
 659     parsed->contents = SHAlloc(stats.st_size+1);
 660     if (parsed->contents == NULL) goto failed;
 661
 662     curr_entry = &parsed->head_comments;
 663     curr_group = &parsed->groups;
 664
 665     if (read(fd, parsed->contents, stats.st_size) == -1) goto failed;
 666     parsed->contents[stats.st_size] = 0;
 667
 668     while (pos < stats.st_size)
 669     {
 670         PARSED_ENTRY statement;
 671         int type, size;
 672
 673         size = parse_line(parsed->contents + pos, &statement, &type);
 674         if (size == -1) goto failed;
 675         if (size == 0)
 676             break;
 677         pos += size;
 678
 679         switch (type)
 680         {
 681             case LINE_GROUP:
 682             {
 683                 PARSED_GROUP *group = SHAlloc(sizeof(PARSED_GROUP));
 684                 if (group == NULL) goto failed;
 685                 is_in_group = TRUE;
 686
 687                 group->name = statement.name;
 688                 group->entries = NULL;
 689                 group->next = NULL;
 690                 *curr_group = group;
 691                 curr_group = &group->next;
 692                 curr_entry = &group->entries;
 693                 break;
 694             }
 695
 696             case LINE_ENTRY:
 697                 if (!is_in_group) goto failed;
 698                 /* fall through */
 699             case LINE_COMMENT:
 700             {
 701                 PARSED_ENTRY *new_stat = SHAlloc(sizeof(PARSED_ENTRY));
 702                 if (new_stat == NULL) goto failed;
 703                 *new_stat = statement;
 704                 new_stat->next = NULL;
 705                 *curr_entry = new_stat;
 706                 curr_entry = &new_stat->next;
 707                 break;
 708             }
 709         }
 710     }
 711     return parsed;
 712
 713 failed:
 714     XDG_FreeParsedFile(parsed);
 715     return NULL;
 716 }
 717
 718 char *XDG_GetStringValue(XDG_PARSED_FILE *file, const char *group_name, const char *value_name, DWORD dwFlags)
 719 {
 720     PARSED_GROUP *group;
 721     PARSED_ENTRY *entry;
 722
 723     for (group = file->groups; group; group = group->next)
 724     {
 725         if (!parsed_str_eq(&group->name, group_name))
 726             continue;
 727
 728         for (entry = group->entries; entry; entry = entry->next)
 729             if (entry->name.str != NULL && parsed_str_eq(&entry->name, value_name))
 730             {
 731                 int len;
 732                 char *ret;
 733
 734                 len = dskentry_decode(entry->value.str, entry->value.len, NULL);
 735                 ret = SHAlloc(len);
 736                 if (ret == NULL) return NULL;
 737                 dskentry_decode(entry->value.str, entry->value.len, ret);
 738                 if (dwFlags & XDG_URLENCODE)
 739                     url_decode(ret, ret);
 740                 return ret;
 741             }
 742     }
 743
 744     return NULL;
 745 }
 746
 747 /* Get the name of the xdg configuration file.
 748  *
 749  * [in] home_dir - $HOME
 750  * [out] config_file - the name of the configuration file
 751  */
 752 static HRESULT get_xdg_config_file(char * home_dir, char ** config_file)
 753 {
 754     char *config_home;
 755
 756     config_home = getenv("XDG_CONFIG_HOME");
 757     if (!config_home || !config_home[0])
 758     {
 759         *config_file = HeapAlloc(GetProcessHeap(), 0, strlen(home_dir) + strlen("/.config/user-dirs.dirs") + 1);
 760         if (!*config_file)
 761             return E_OUTOFMEMORY;
 762
 763         strcpy(*config_file, home_dir);
 764         strcat(*config_file, "/.config/user-dirs.dirs");
 765     }
 766     else
 767     {
 768         *config_file = HeapAlloc(GetProcessHeap(), 0, strlen(config_home) + strlen("/user-dirs.dirs") + 1);
 769         if (!*config_file)
 770             return E_OUTOFMEMORY;
 771
 772         strcpy(*config_file, config_home);
 773         strcat(*config_file, "/user-dirs.dirs");
 774     }
 775     return S_OK;
 776 }
 777
 778 /* Parse the key in a line in the xdg-user-dir config file.
 779  * i.e. XDG_PICTURES_DIR="$HOME/Pictures"
 780  *      ^                ^
 781  *
 782  * [in] xdg_dirs - array of xdg directories to look for
 783  * [in] num_dirs - number of elements in xdg_dirs
 784  * [in/out] p_ptr - pointer to where we are in the buffer
 785  * Returns the index to xdg_dirs if we find the key, or -1 on error.
 786  */
 787 static int parse_config1(const char * const *xdg_dirs, const unsigned int num_dirs, char ** p_ptr)
 788 {
 789     char *p;
 790     int i;
 791
 792     p = *p_ptr;
 793     while (*p == ' ' || *p == '\t')
 794         p++;
 795     if (strncmp(p, "XDG_", 4))
 796         return -1;
 797
 798     p += 4;
 799     for (i = 0; i < num_dirs; i++)
 800     {
 801         if (!strncmp(p, xdg_dirs[i], strlen(xdg_dirs[i])))
 802         {
 803             p += strlen(xdg_dirs[i]);
 804             break;
 805         }
 806     }
 807     if (i == num_dirs)
 808         return -1;
 809     if (strncmp(p, "_DIR", 4))
 810         return -1;
 811     p += 4;
 812     while (*p == ' ' || *p == '\t')
 813         p++;
 814     if (*p != '=')
 815         return -1;
 816     p++;
 817     while (*p == ' ' || *p == '\t')
 818         p++;
 819     if (*p != '"')
 820         return -1;
 821     p++;
 822
 823     *p_ptr = p;
 824     return i;
 825 }
 826
 827 /* Parse the value in a line in the xdg-user-dir config file.
 828  * i.e. XDG_PICTURES_DIR="$HOME/Pictures"
 829  *                        ^             ^
 830  *
 831  * [in] p - pointer to the buffer
 832  * [in] home_dir - $HOME
 833  * [out] out_ptr - the directory name
 834  */
 835 static HRESULT parse_config2(char * p, const char * home_dir, char ** out_ptr)
 836 {
 837     BOOL relative;
 838     char *out, *d;
 839
 840     relative = FALSE;
 841
 842     if (!strncmp(p, "$HOME/", 6))
 843     {
 844         p += 6;
 845         relative = TRUE;
 846     }
 847     else if (*p != '/')
 848         return E_FAIL;
 849
 850     if (relative)
 851     {
 852         out = HeapAlloc(GetProcessHeap(), 0, strlen(home_dir) + strlen(p) + 2);
 853         if (!out)
 854             return E_OUTOFMEMORY;
 855
 856         strcpy(out, home_dir);
 857         strcat(out, "/");
 858     }
 859     else
 860     {
 861         out = HeapAlloc(GetProcessHeap(), 0, strlen(p) + 1);
 862         if (!out)
 863             return E_OUTOFMEMORY;
 864         *out = 0;
 865     }
 866
 867     d = out + strlen(out);
 868     while (*p && *p != '"')
 869     {
 870         if ((*p == '\\') && (*(p + 1) != 0))
 871             p++;
 872         *d++ = *p++;
 873     }
 874     *d = 0;
 875     *out_ptr = out;
 876     return S_OK;
 877 }
 878
 879 /* Parse part of a line in the xdg-user-dir config file.
 880  * i.e. XDG_PICTURES_DIR="$HOME/Pictures"
 881  *                        ^             ^
 882  *
 883  * The calling function is responsible for freeing all elements of out_ptr as
 884  * well as out_ptr itself.
 885  *
 886  * [in] xdg_dirs - array of xdg directories to look for
 887  * [in] num_dirs - number of elements in xdg_dirs
 888  * [out] out_ptr - an array of the xdg directories names
 889  */
 890 HRESULT XDG_UserDirLookup(const char * const *xdg_dirs, const unsigned int num_dirs, char *** out_ptr)
 891 {
 892     FILE *file;
 893     char **out;
 894     char *home_dir, *config_file;
 895     char buffer[512];
 896     int len;
 897     unsigned int i;
 898     HRESULT hr;
 899
 900     *out_ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_dirs * sizeof(char *));
 901     out = *out_ptr;
 902     if (!out)
 903         return E_OUTOFMEMORY;
 904
 905     home_dir = getenv("HOME");
 906     if (!home_dir)
 907     {
 908         hr = E_FAIL;
 909         goto xdg_user_dir_lookup_error;
 910     }
 911
 912     hr = get_xdg_config_file(home_dir, &config_file);
 913     if (FAILED(hr))
 914         goto xdg_user_dir_lookup_error;
 915
 916     file = fopen(config_file, "r");
 917     HeapFree(GetProcessHeap(), 0, config_file);
 918     if (!file)
 919     {
 920         hr = E_HANDLE;
 921         goto xdg_user_dir_lookup_error;
 922     }
 923
 924     while (fgets(buffer, sizeof(buffer), file))
 925     {
 926         int idx;
 927         char *p;
 928
 929         /* Remove newline at end */
 930         len = strlen(buffer);
 931         if (len > 0 && buffer[len-1] == '\n')
 932             buffer[len-1] = 0;
 933
 934         /* Parse the key */
 935         p = buffer;
 936         idx = parse_config1(xdg_dirs, num_dirs, &p);
 937         if (idx < 0)
 938             continue;
 939         if (out[idx])
 940             continue;
 941
 942         /* Parse the value */
 943         hr = parse_config2(p, home_dir, &out[idx]);
 944         if (FAILED(hr))
 945         {
 946             if (hr == E_OUTOFMEMORY)
 947             {
 948                 fclose(file);
 949                 goto xdg_user_dir_lookup_error;
 950             }
 951             continue;
 952         }
 953     }
 954     fclose (file);
 955     hr = S_OK;
 956
 957     /* Remove entries for directories that do not exist */
 958     for (i = 0; i <  num_dirs; i++)
 959     {
 960         struct stat statFolder;
 961
 962         if (!out[i])
 963             continue;
 964         if (!stat(out[i], &statFolder) && S_ISDIR(statFolder.st_mode))
 965             continue;
 966         HeapFree(GetProcessHeap(), 0, out[i]);
 967         out[i] = NULL;
 968     }
 969
 970 xdg_user_dir_lookup_error:
 971     if (FAILED(hr))
 972     {
 973         for (i = 0; i < num_dirs; i++) HeapFree(GetProcessHeap(), 0, out[i]);
 974         HeapFree(GetProcessHeap(), 0, *out_ptr);
 975     }
 976     return hr;
 977 }