wks: Allow reading of --install-key arguments from stdin.
[gnupg.git] / common / helpfile.c
1 /* helpfile.c - GnuPG's helpfile feature
2  *      Copyright (C) 2007 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * This file is free software; you can redistribute it and/or modify
7  * it under the terms of either
8  *
9  *   - the GNU Lesser General Public License as published by the Free
10  *     Software Foundation; either version 3 of the License, or (at
11  *     your option) any later version.
12  *
13  * or
14  *
15  *   - the GNU General Public License as published by the Free
16  *     Software Foundation; either version 2 of the License, or (at
17  *     your option) any later version.
18  *
19  * or both in parallel, as here.
20  *
21  * This file is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, see <https://www.gnu.org/licenses/>.
28  */
29
30 #include <config.h>
31 #include <stdlib.h>
32
33
34 #include "util.h"
35 #include "i18n.h"
36 #include "membuf.h"
37
38
39 /* Try to find KEY in the file FNAME.  */
40 static char *
41 findkey_fname (const char *key, const char *fname)
42 {
43   gpg_error_t err = 0;
44   FILE *fp;
45   int lnr = 0;
46   int c;
47   char *p, line[256];
48   int in_item = 0;
49   membuf_t mb = MEMBUF_ZERO;
50
51   fp = fopen (fname, "r");
52   if (!fp)
53     {
54       if (errno != ENOENT)
55         {
56           err = gpg_error_from_syserror ();
57           log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
58         }
59       return NULL;
60     }
61
62   while (fgets (line, DIM(line)-1, fp))
63     {
64       lnr++;
65
66       if (!*line || line[strlen(line)-1] != '\n')
67         {
68           /* Eat until end of line. */
69           while ( (c=getc (fp)) != EOF && c != '\n')
70             ;
71           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
72                            : GPG_ERR_INCOMPLETE_LINE);
73           log_error (_("file '%s', line %d: %s\n"),
74                      fname, lnr, gpg_strerror (err));
75         }
76       else
77         line[strlen(line)-1] = 0; /* Chop the LF. */
78
79     again:
80       if (!in_item)
81         {
82           /* Allow for empty lines and spaces while not in an item. */
83           for (p=line; spacep (p); p++)
84             ;
85           if (!*p || *p == '#')
86             continue;
87           if (*line != '.' || spacep(line+1))
88             {
89               log_info (_("file '%s', line %d: %s\n"),
90                         fname, lnr, _("ignoring garbage line"));
91               continue;
92             }
93           trim_trailing_spaces (line);
94           in_item = 1;
95           if (!strcmp (line+1, key))
96             {
97               /* Found.  Start collecting.  */
98               init_membuf (&mb, 1024);
99             }
100           continue;
101         }
102
103       /* If in an item only allow for comments in the first column
104          and provide ". " as an escape sequence to allow for
105          leading dots and hash marks in the actual text.  */
106       if (*line == '#')
107         continue;
108       if (*line == '.')
109         {
110           if (spacep(line+1))
111             p = line + 2;
112           else
113             {
114               trim_trailing_spaces (line);
115               in_item = 0;
116               if (is_membuf_ready (&mb))
117                 break;        /* Yep, found and collected the item.  */
118               if (!line[1])
119                 continue;     /* Just an end of text dot. */
120               goto again;     /* A new key line.  */
121             }
122         }
123       else
124         p = line;
125
126       if (is_membuf_ready (&mb))
127         {
128           put_membuf_str (&mb, p);
129           put_membuf (&mb, "\n", 1);
130         }
131
132     }
133   if ( !err && ferror (fp) )
134     {
135       err = gpg_error_from_syserror ();
136       log_error (_("error reading '%s', line %d: %s\n"),
137                  fname, lnr, gpg_strerror (err));
138     }
139
140   fclose (fp);
141   if (is_membuf_ready (&mb))
142     {
143       /* We have collected something.  */
144       if (err)
145         {
146           xfree (get_membuf (&mb, NULL));
147           return NULL;
148         }
149       else
150         {
151           put_membuf (&mb, "", 1);  /* Terminate string.  */
152           return get_membuf (&mb, NULL);
153         }
154     }
155   else
156     return NULL;
157 }
158
159
160 /* Try the help files depending on the locale.  */
161 static char *
162 findkey_locale (const char *key, const char *locname,
163                 int only_current_locale, const char *dirname)
164 {
165   const char *s;
166   char *fname, *ext, *p;
167   char *result;
168
169   fname = xtrymalloc (strlen (dirname) + 6 + strlen (locname) + 4 + 1);
170   if (!fname)
171     return NULL;
172   ext = stpcpy (stpcpy (fname, dirname), "/help.");
173   /* Search with locale name and territory.  ("help.LL_TT.txt") */
174   if (strchr (locname, '_'))
175     {
176       strcpy (stpcpy (ext, locname), ".txt");
177       result = findkey_fname (key, fname);
178     }
179   else
180     result = NULL;  /* No territory.  */
181
182   if (!result)
183     {
184       /* Search with just the locale name - if any. ("help.LL.txt") */
185       if (*locname)
186         {
187           for (p=ext, s=locname; *s && *s != '_';)
188             *p++ = *s++;
189           strcpy (p, ".txt");
190           result = findkey_fname (key, fname);
191         }
192       else
193         result = NULL;
194     }
195
196   if (!result && (!only_current_locale || !*locname) )
197     {
198       /* Last try: Search in file without any locale info.  ("help.txt") */
199       strcpy (ext, "txt");
200       result = findkey_fname (key, fname);
201     }
202
203   xfree (fname);
204   return result;
205 }
206
207
208 /* Return a malloced help text as identified by KEY.  The system takes
209    the string from an UTF-8 encoded file to be created by an
210    administrator or as distributed with GnuPG.  On a GNU or Unix
211    system the entry is searched in these files:
212
213      /etc/gnupg/help.LL.txt
214      /etc/gnupg/help.txt
215      /usr/share/gnupg/help.LL.txt
216      /usr/share/gnupg/help.txt
217
218    Here LL denotes the two digit language code of the current locale.
219    If ONLY_CURRENT_LOCALE is set, the function won't fallback to the
220    english valiant ("help.txt") unless that locale has been requested.
221
222    The help file needs to be encoded in UTF-8, lines with a '#' in the
223    first column are comment lines and entirely ignored.  Help keys are
224    identified by a key consisting of a single word with a single dot
225    as the first character.  All key lines listed without any
226    intervening lines (except for comment lines) lead to the same help
227    text.  Lines following the key lines make up the actual hep texts.
228
229 */
230
231 char *
232 gnupg_get_help_string (const char *key, int only_current_locale)
233 {
234   static const char *locname;
235   char *result;
236
237   if (!locname)
238     {
239       char *buffer, *p;
240       int count = 0;
241       const char *s = gnupg_messages_locale_name ();
242       buffer = xtrystrdup (s);
243       if (!buffer)
244         locname = "";
245       else
246         {
247           for (p = buffer; *p; p++)
248             if (*p == '.' || *p == '@' || *p == '/' /*(safeguard)*/)
249               *p = 0;
250             else if (*p == '_')
251               {
252                 if (count++)
253                   *p = 0;  /* Also cut at a underscore in the territory.  */
254               }
255           locname = buffer;
256         }
257     }
258
259   if (!key || !*key)
260     return NULL;
261
262   result = findkey_locale (key, locname, only_current_locale,
263                            gnupg_sysconfdir ());
264   if (!result)
265     result = findkey_locale (key, locname, only_current_locale,
266                              gnupg_datadir ());
267
268   if (result)
269     trim_trailing_spaces (result);
270
271   return result;
272 }