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