shell32: Allow overwriting files in SHFileOperation(FO_COPY) (with confirmation dialogs).
[wine] / 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 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #ifdef HAVE_SYS_STAT_H
27 # include <sys/stat.h>
28 #endif
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <errno.h>
33  
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winreg.h"
37 #include "shlwapi.h"
38 #include "wine/debug.h"
39 #include "shell32_main.h"
40 #include "xdg.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(xdg);
43
44 /*
45  * XDG paths implemented using Desktop Base Directory spec version 0.6
46  * (from http://standards.freedesktop.org/basedir-spec/basedir-spec-0.6.html)
47  */
48
49 static CRITICAL_SECTION XDG_PathsLock;
50 static CRITICAL_SECTION_DEBUG XDG_PathsLock_Debug =
51 {
52     0, 0, &XDG_PathsLock,
53     { &XDG_PathsLock_Debug.ProcessLocksList,
54       &XDG_PathsLock_Debug.ProcessLocksList},
55     0, 0, { (DWORD_PTR)__FILE__ ": XDG_PathsLock"}
56 };
57 static CRITICAL_SECTION XDG_PathsLock = { &XDG_PathsLock_Debug, -1, 0, 0, 0, 0 };
58
59 typedef struct
60 {
61     const char *var_name;
62     const char *default_value;
63 } std_path;
64
65 static const std_path paths[] = {
66     {"XDG_DATA_HOME", "$HOME/.local/share"},
67     {"XDG_CONFIG_HOME", "$HOME/.config"},
68     {"XDG_DATA_DIRS", "/usr/local/share:/usr/share"},
69     {"XDG_CONFIG_DIRS", "/etc/xdg"},
70     {"XDG_CACHE_HOME", "$HOME/.cache"}
71 };
72
73 #define PATHS_COUNT (sizeof(paths)/sizeof(paths[0]))
74
75 /* will be filled with paths as they are computed */
76 static const char *path_values[PATHS_COUNT] = {
77     NULL,
78     NULL,
79     NULL,
80     NULL,
81     NULL
82 };
83
84 static char *load_path(int path_id)
85 {
86     char *env = getenv(paths[path_id].var_name);
87     char *ret;
88     
89     if (env != NULL && env[0]=='/')
90     {
91         ret = SHAlloc(strlen(env)+1);
92         if (ret != NULL)
93             lstrcpyA(ret, env);
94         return ret;
95     }
96     
97     if (memcmp(paths[path_id].default_value, "$HOME", 5)==0)
98     {
99         char *home = getenv("HOME");
100         int len;
101
102         if (!home) return NULL;
103         ret = SHAlloc(strlen(home)+strlen(paths[path_id].default_value)-5+1);
104         if (ret == NULL) return NULL;
105         
106         lstrcpyA(ret, home);
107         len = strlen(ret);
108         if (len>0 && ret[len-1]=='/')
109             ret[--len]=0;
110         lstrcatA(ret, paths[path_id].default_value+5);
111         return ret;
112     }
113     
114     ret = SHAlloc(strlen(paths[path_id].default_value)+1);
115     if (ret != NULL)
116         lstrcpyA(ret, env);
117     return ret;
118 }
119
120 /******************************************************************************
121  * XDG_GetPath    [internal]
122  *
123  * Get one of the XDG standard patch. The return value shouldn't be modified nor
124  * freed. A return value of NULL means that the memory is exhausted or the input
125  * is invalid
126  *
127  * For XDG_DATA_HOME, XDG_CONFIG_HOME and XDG_CACHE_HOME the result is a Unix path.
128  * For XDG_DATA_DIRS and XDG_CONFIG_DIRS the result is a colon-separated list of Unix
129  * paths
130  *
131  * The paths are guaranteed to start with '/'
132  */
133 const char *XDG_GetPath(int path_id)
134 {
135     if (path_id >= PATHS_COUNT || path_id < 0)
136     {
137         ERR("Invalid path_id %d\n", path_id);
138         return NULL;
139     }
140     
141     if (path_values[path_id] != NULL)
142         return path_values[path_id];
143     EnterCriticalSection(&XDG_PathsLock);
144     if (path_values[path_id] == NULL)
145         path_values[path_id] = load_path(path_id);
146     LeaveCriticalSection(&XDG_PathsLock);
147     return path_values[path_id];
148 }
149
150 /******************************************************************************
151  * XDG_BuildPath    [internal]
152  *
153  * Build a string with a subpath of one of the XDG standard paths.
154  * The root can be one of XDG_DATA_HOME, XDG_CONFIG_HOME and XDG_CACHE_HOME.
155  * The subpath is a path relative to that root (it shouldn't start with a slash)
156  *
157  * The returned path should be freed with SHFree. A return of NULL means that the
158  * memory is exhausted or the parameters are invalid
159  */
160 char *XDG_BuildPath(int root_id, const char *subpath)
161 {
162     const char *root_path = XDG_GetPath(root_id);
163     char *ret_buffer;
164     int root_len;
165     
166     if (root_id == XDG_DATA_DIRS || root_id == XDG_CONFIG_DIRS)
167     {
168         ERR("Invalid path id %d\n", root_id);
169         return NULL;
170     }
171     
172     if (root_path == NULL) return NULL;
173     root_len = strlen(root_path);
174     if (root_path[root_len-1]=='/') root_len--;
175     ret_buffer = SHAlloc(root_len+1+strlen(subpath)+1);
176     if (ret_buffer == NULL) return NULL;
177     lstrcpyA(ret_buffer, root_path);
178     ret_buffer[root_len]='/';
179     lstrcpyA(ret_buffer+root_len+1, subpath);
180     return ret_buffer;
181 }
182
183 /******************************************************************************
184  * XDG_MakeDirs    [internal]
185  *
186  * Checks that all the directories on the specified path exists. If some don't exists
187  * they are created with mask 0700 as required by many the freedeskop.org specs.
188  * If the path doesn't end with '/' it is assumed to be a path to a file and the last
189  * segment is not checked
190  *
191  * In case of a failure the errno is always set and can be used e.g for debugging
192  *
193  * RETURNS
194  *   TRUE on success, FALSE on error
195  */
196 BOOL XDG_MakeDirs(const char *path)
197 {
198     int last_slash = 0;
199     BOOL success = TRUE;
200     struct stat tmp;
201     char *buffer = SHAlloc(strlen(path)+1);
202     
203     if (buffer == NULL)
204     {
205         errno = ENOMEM;
206         return FALSE;
207     }
208     lstrcpyA(buffer, path);
209     
210     TRACE("(%s)\n", debugstr_a(path));
211     while (1)
212     {
213         char *slash=strchr(buffer+last_slash+1, '/');
214         if (slash==NULL)
215             break;
216         
217         /* cut the string at that position and create the directory if it doesn't exist */
218         *slash=0;
219         TRACE("Checking path %s\n", debugstr_a(buffer));
220         success = (stat(buffer, &tmp)==0);
221         if (!success && errno==ENOENT)
222         {
223             TRACE("Creating\n");
224             success = (mkdir(buffer, 0700)==0);
225         }
226         if (!success)
227         {
228             WARN("Couldn't process directory %s (errno=%d)\n", debugstr_a(buffer), errno);
229             break;
230         }
231         *slash='/';
232         last_slash = slash-buffer;
233     }
234     SHFree(buffer);
235     return success;
236 }
237
238 /*
239  * .desktop files functions
240  */
241
242
243 /******************************************************************************
244  * dskentry_encode    [internal]
245  *
246  * Escape the characters that can't be present in a desktop entry value like \n, leading
247  * spaces etc. The output parameter may be NULL. Then only the number of characters will
248  * be computers.
249  *
250  * RETURNS
251  *   The number of characters after escaping the special characters, including the
252  * terminating NUL.
253  */
254 static int dskentry_encode(const char *value, char *output)
255 {
256     int only_spc = TRUE;
257     int num_written = 0;
258     const char *c;
259     for (c = value; *c; c++)
260     {
261         if (only_spc && *c==' ')
262         {
263             if (output)
264             {
265                 *(output++) = '\\';
266                 *(output++) = 's';
267             }
268             num_written += 2;
269             continue;
270         }
271         only_spc = FALSE;
272         
273         if (*c=='\t' || *c=='\r' || *c=='\n' || *c=='\\')
274         {
275             if (output)
276             {
277                 *(output++) = '\\';
278                 if (*c=='\t') *(output++) = 't';
279                 if (*c=='\r') *(output++) = 'r';
280                 if (*c=='\n') *(output++) = 'n';
281                 if (*c=='\\') *(output++) = '\\';
282             }
283             num_written += 2;
284         }
285         else
286         {
287             if (output)
288                 *(output++)=*c;
289             num_written++;
290         }
291     }
292     
293     if (output)
294         *(output++) = 0;
295     num_written++;
296     return num_written;
297 }
298
299 /******************************************************************************
300  * dskentry_decode    [internal]
301  *
302  * Unescape the characters that can be escaped according to the desktop entry spec.
303  * The output parameter may be NULL. Then only the number of characters will
304  * be computers.
305  *
306  * RETURNS
307  *   The number of characters after unescaping the special characters, including the
308  * terminating NUL.
309  */
310 static int dskentry_decode(const char *value, int len, char *output)
311 {
312     int pos = 0;
313     int count = 0;
314     while (pos<len)
315     {
316         char c;
317         if (value[pos] == '\\' && pos<len-1)
318         {
319             pos++;
320             switch (value[pos])
321             {
322                 case 's': c = ' '; break;
323                 case 'n': c = '\n'; break;
324                 case 't': c = '\t'; break;
325                 case 'r': c = 'r'; break;
326                 case '\\': c = '\\'; break;
327                 default:
328                     /* store both the backslash and the character */
329                     if (output)
330                         *(output++) = '\\';
331                     count++;
332                     c = value[pos];
333                     break;
334             }
335         }
336         else
337             c = value[pos];
338             
339         if (output)
340             *(output++) = c;
341         count++;
342         pos++;
343     }
344     
345     if (output)
346         *(output++) = 0;
347     count++;
348     return count;
349 }
350
351
352 /******************************************************************************
353  * url_encode    [internal]
354  *
355  * URL-encode the given string (i.e. use escape codes like %20). Note that an
356  * URL-encoded string can be used as a value in desktop entry files as all
357  * unsafe characters are escaped.
358  *
359  * The output can be NULL. Then only the number of characters will be counted
360  *
361  * RETURNS
362  *   The number of characters after escaping the special characters, including the
363  * terminating NUL.
364  */
365 static int url_encode(const char *value, char *output)
366 {
367     static const char unsafechars[] = "^&`{}|[]'<>\\#%\"+";
368     static const char hexchars[] = "0123456789ABCDEF";
369     int num_written = 0;
370     const char *c;
371
372     for (c = value; *c; c++)
373     {
374         if (*c<=0x20 || *c>=0x7f || strchr(unsafechars, *c))
375         {
376             if (output)
377             {
378                 *(output++) = '%';
379                 *(output++) = hexchars[(unsigned)(*c)/16];
380                 *(output++) = hexchars[(unsigned)(*c)%16];
381             }
382             num_written += 3;
383         }
384         else
385         {
386             if (output)
387                 *(output++) = *c;
388             num_written++;
389         }
390     }
391
392     if (output)
393         *(output++) = 0;
394     num_written++;
395
396     return num_written;
397 }
398
399 static int decode_url_code(const char *c)
400 {
401     const char *p1, *p2;
402     int v1, v2;
403     static const char hexchars[] = "0123456789ABCDEF";
404     if (*c == 0)
405         return -1;
406
407     p1 = strchr(hexchars, toupper(*c));
408     p2 = strchr(hexchars, toupper(*(c+1)));
409     if (p1 == NULL || p2 == NULL)
410         return -1;
411     v1 = (int)(p1 - hexchars);
412     v2 = (int)(p2 - hexchars);
413     return (v1<<4) + v2;
414 }
415
416 /******************************************************************************
417  * url_decode    [internal]
418  *
419  * URL-decode the given string (i.e. unescape codes like %20). The decoded string
420  * will never be longer than the encoded one. The decoding can be done in place - the
421  * output variable can point to the value buffer.
422  *
423  * output should not be NULL
424  */
425 static void url_decode(const char *value, char *output)
426 {
427     const char *c = value;
428     while (*c)
429     {
430         if (*c == '%')
431         {
432             int v = decode_url_code(c+1);
433             if (v != -1)
434             {
435                 *(output++) = v;
436                 c += 3;
437                 continue;
438             }
439         }
440         
441         *(output++) = *c;
442         c++;
443     }
444     *output = 0;
445 }
446
447 static int escape_value(const char *value, DWORD dwFlags, char *output)
448 {
449     if (dwFlags & XDG_URLENCODE)
450         return url_encode(value, output);
451     return dskentry_encode(value, output);
452 }
453
454 /******************************************************************************
455  * XDG_WriteDesktopStringEntry    [internal]
456  *
457  * Writes a key=value pair into the specified file descriptor.
458  *
459  * RETURNS
460  *   TRUE on success, else FALSE
461  */
462 BOOL XDG_WriteDesktopStringEntry(int writer, const char *keyName, DWORD dwFlags, const char *value)
463 {
464     int keyLen = lstrlenA(keyName);
465     int valueLen = escape_value(value, dwFlags, NULL);
466     char *string = SHAlloc(keyLen+1+valueLen);
467     BOOL ret;
468     
469     if (string == NULL)
470         return FALSE;
471     lstrcpyA(string, keyName);
472     string[keyLen] = '=';
473     escape_value(value, dwFlags, string+keyLen+1);
474     string[keyLen+1+valueLen-1]='\n';   /* -1 because valueLen contains the last NUL character */
475     ret = (write(writer, string, keyLen+1+valueLen)!=-1);
476     SHFree(string);
477     return ret;
478 }
479
480 typedef struct
481 {
482     char *str;
483     int len;
484 } PARSED_STRING;
485
486 typedef struct tagPARSED_ENTRY PARSED_ENTRY;
487 struct tagPARSED_ENTRY
488 {
489     PARSED_STRING name;
490     PARSED_STRING equals;
491     PARSED_STRING value;
492     PARSED_ENTRY *next;
493 };
494
495 typedef struct tagPARSED_GROUP PARSED_GROUP;
496 struct tagPARSED_GROUP
497 {
498     PARSED_STRING name;
499     PARSED_ENTRY *entries;
500     PARSED_GROUP *next;
501 };
502
503
504 struct tagXDG_PARSED_FILE
505 {
506     char *contents;
507     PARSED_ENTRY *head_comments;
508     PARSED_GROUP *groups;
509 };
510
511 static BOOL parsed_str_eq(PARSED_STRING *str1, const char *str2)
512 {
513     if (strncmp(str1->str, str2, str1->len) != 0)
514         return FALSE;
515     if (str2[str1->len] != 0)
516         return FALSE;
517     return TRUE;
518 }
519
520 static void free_entries_list(PARSED_ENTRY *first)
521 {
522     PARSED_ENTRY *next;
523     while (first)
524     {
525         next = first->next;
526         SHFree(first);
527         first = next;
528     }
529 }
530
531 void XDG_FreeParsedFile(XDG_PARSED_FILE *parsed)
532 {
533     PARSED_GROUP *group, *next;
534     if (!parsed)
535         return;
536     free_entries_list(parsed->head_comments);
537     
538     group = parsed->groups;
539     while (group)
540     {
541         next = group->next;
542         free_entries_list(group->entries);
543         SHFree(group);
544         group = next;
545     }
546 }
547
548 #define LINE_GROUP   1
549 #define LINE_ENTRY   2
550 #define LINE_COMMENT 3
551
552 static int parse_line(char *content, PARSED_ENTRY *output, int *outType)
553 {
554     char *end;
555     
556     ZeroMemory(output, sizeof(PARSED_ENTRY));
557     end = strchr(content, '\n');
558     if (end == NULL)
559         end = content + strlen(content) - 1;
560     
561     if (*content == '#')
562     {
563         *outType = LINE_COMMENT;
564         output->equals.str = content;
565         output->equals.len = end - content;
566         if (*end != '\n')
567             output->equals.len++;
568     }
569     else if (*content == '[')
570     {
571         char *last_char = end;
572         
573         *outType = LINE_GROUP;
574         
575         /* the standard says nothing about skipping white spaces but e.g. KDE accepts such files */
576         while (isspace(*last_char))
577             last_char--;
578         if (*last_char != ']')
579             return -1;
580         output->name.str = content + 1;
581         output->name.len = last_char - (content + 1);
582     }
583     else
584     {
585         /* 'name = value' line */
586         char *equal, *eq_begin, *eq_end;
587         
588         *outType = LINE_ENTRY;
589         
590         equal = strchr(content, '=');
591         if (equal == NULL || equal > end)
592             return -1;
593         for (eq_begin = equal-1;  isspace(*eq_begin) && eq_begin >= content; eq_begin--)
594             ;
595         for (eq_end = equal+1; isspace(*eq_end) && *eq_end != '\n'; eq_end++)
596             ;
597
598         output->name.str = content;
599         output->name.len = eq_begin - content + 1;
600
601         output->equals.str = eq_begin + 1;
602         output->equals.len = eq_end - eq_begin - 1;
603         
604         output->value.str = eq_end;
605         output->value.len = end - eq_end;
606
607         if (*end != '\n')
608             output->value.len++;
609     }
610     return end - content + 1;
611 }
612
613 XDG_PARSED_FILE *XDG_ParseDesktopFile(int fd)
614 {
615     struct stat stats;
616     XDG_PARSED_FILE *parsed = NULL;
617     PARSED_ENTRY **curr_entry;
618     PARSED_GROUP **curr_group;
619     BOOL is_in_group = FALSE;
620     
621     int pos = 0;
622     
623     if (fstat(fd, &stats) == -1) goto failed;
624     parsed = SHAlloc(sizeof(XDG_PARSED_FILE));
625     if (parsed == NULL) goto failed;
626     parsed->groups = NULL;
627     parsed->head_comments = NULL;
628     parsed->contents = SHAlloc(stats.st_size+1);
629     if (parsed->contents == NULL) goto failed;
630     
631     curr_entry = &parsed->head_comments;
632     curr_group = &parsed->groups;
633     
634     if (read(fd, parsed->contents, stats.st_size) == -1) goto failed;
635     parsed->contents[stats.st_size] = 0;
636
637     while (pos < stats.st_size)
638     {
639         PARSED_ENTRY statement;
640         int type, size;
641
642         size = parse_line(parsed->contents + pos, &statement, &type);
643         if (size == -1) goto failed;
644         if (size == 0)
645             break;
646         pos += size;
647         
648         switch (type)
649         {
650             case LINE_GROUP:
651             {
652                 PARSED_GROUP *group = SHAlloc(sizeof(PARSED_GROUP));
653                 if (group == NULL) goto failed;
654                 is_in_group = TRUE;
655                 
656                 group->name = statement.name;
657                 group->entries = NULL;
658                 group->next = NULL;
659                 *curr_group = group;
660                 curr_group = &group->next;
661                 curr_entry = &group->entries;
662                 break;
663             }
664
665             case LINE_ENTRY:
666                 if (!is_in_group) goto failed;
667                 /* fall through */
668             case LINE_COMMENT:
669             {
670                 PARSED_ENTRY *new_stat = SHAlloc(sizeof(PARSED_ENTRY));
671                 if (new_stat == NULL) goto failed;
672                 *new_stat = statement;
673                 new_stat->next = NULL;
674                 *curr_entry = new_stat;
675                 curr_entry = &new_stat->next;
676                 break;
677             }
678         }
679     }
680     return parsed;
681     
682 failed:
683     XDG_FreeParsedFile(parsed);
684     return NULL;
685 }
686
687 char *XDG_GetStringValue(XDG_PARSED_FILE *file, const char *group_name, const char *value_name, DWORD dwFlags)
688 {
689     PARSED_GROUP *group;
690     PARSED_ENTRY *entry;
691
692     for (group = file->groups; group; group = group->next)
693     {
694         if (!parsed_str_eq(&group->name, group_name))
695             continue;
696
697         for (entry = group->entries; entry; entry = entry->next)
698             if (entry->name.str != NULL && parsed_str_eq(&entry->name, value_name))
699             {
700                 int len;
701                 char *ret;
702                 
703                 len = dskentry_decode(entry->value.str, entry->value.len, NULL);
704                 ret = SHAlloc(len);
705                 if (ret == NULL) return NULL;
706                 dskentry_decode(entry->value.str, entry->value.len, ret);
707                 if (dwFlags & XDG_URLENCODE)
708                     url_decode(ret, ret);
709                 return ret;
710             }
711     }
712     
713     return NULL;
714 }