1 /*
2 * sh-i18n--envsubst.c - a stripped-down version of gettext's envsubst(1)
3 *
4 * Copyright (C) 2010 Ævar Arnfjörð Bjarmason
5 *
6 * This is a modified version of
7 * 67d0871a8c:gettext-runtime/src/envsubst.c from the gettext.git
8 * repository. It has been stripped down to only implement the
9 * envsubst(1) features that we need in the git-sh-i18n fallbacks.
10 *
11 * The "Close standard error" part in main() is from
12 * 8dac033df0:gnulib-local/lib/closeout.c. The copyright notices for
13 * both files are reproduced immediately below.
14 */
15
16 #include "git-compat-util.h"
17 #include "trace2.h"
18
19 /* Substitution of environment variables in shell format strings.
20 Copyright (C) 2003-2007 Free Software Foundation, Inc.
21 Written by Bruno Haible <bruno@clisp.org>, 2003.
22
23 This program is free software; you can redistribute it and/or modify
24 it under the terms of the GNU General Public License as published by
25 the Free Software Foundation; either version 2, or (at your option)
26 any later version.
27
28 This program is distributed in the hope that it will be useful,
29 but WITHOUT ANY WARRANTY; without even the implied warranty of
30 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 GNU General Public License for more details.
32
33 You should have received a copy of the GNU General Public License
34 along with this program; if not, see <http://www.gnu.org/licenses/>. */
35
36 /* closeout.c - close standard output and standard error
37 Copyright (C) 1998-2007 Free Software Foundation, Inc.
38
39 This program is free software; you can redistribute it and/or modify
40 it under the terms of the GNU General Public License as published by
41 the Free Software Foundation; either version 2, or (at your option)
42 any later version.
43
44 This program is distributed in the hope that it will be useful,
45 but WITHOUT ANY WARRANTY; without even the implied warranty of
46 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 GNU General Public License for more details.
48
49 You should have received a copy of the GNU General Public License
50 along with this program; if not, see <http://www.gnu.org/licenses/>. */
51
52 #include <errno.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56
57 /* If true, substitution shall be performed on all variables. */
58 static unsigned short int all_variables;
59
60 /* Forward declaration of local functions. */
61 static void print_variables (const char *string);
62 static void note_variables (const char *string);
63 static void subst_from_stdin (void);
64
65 int
cmd_main(int argc,const char * argv[])66 cmd_main (int argc, const char *argv[])
67 {
68 /* Default values for command line options. */
69 /* unsigned short int show_variables = 0; */
70
71 trace2_cmd_name("sh-i18n--envsubst");
72
73 switch (argc)
74 {
75 case 1:
76 error ("we won't substitute all variables on stdin for you");
77 break;
78 /*
79 all_variables = 1;
80 subst_from_stdin ();
81 */
82 case 2:
83 /* echo '$foo and $bar' | git sh-i18n--envsubst --variables '$foo and $bar' */
84 all_variables = 0;
85 note_variables (argv[1]);
86 subst_from_stdin ();
87 break;
88 case 3:
89 /* git sh-i18n--envsubst --variables '$foo and $bar' */
90 if (strcmp(argv[1], "--variables"))
91 error ("first argument must be --variables when two are given");
92 /* show_variables = 1; */
93 print_variables (argv[2]);
94 break;
95 default:
96 error ("too many arguments");
97 break;
98 }
99
100 /* Close standard error. This is simpler than fwriteerror_no_ebadf, because
101 upon failure we don't need an errno - all we can do at this point is to
102 set an exit status. */
103 errno = 0;
104 if (ferror (stderr) || fflush (stderr))
105 {
106 fclose (stderr);
107 return (EXIT_FAILURE);
108 }
109 if (fclose (stderr) && errno != EBADF)
110 return (EXIT_FAILURE);
111
112 return (EXIT_SUCCESS);
113 }
114
115 /* Parse the string and invoke the callback each time a $VARIABLE or
116 ${VARIABLE} construct is seen, where VARIABLE is a nonempty sequence
117 of ASCII alphanumeric/underscore characters, starting with an ASCII
118 alphabetic/underscore character.
119 We allow only ASCII characters, to avoid dependencies w.r.t. the current
120 encoding: While "${\xe0}" looks like a variable access in ISO-8859-1
121 encoding, it doesn't look like one in the BIG5, BIG5-HKSCS, GBK, GB18030,
122 SHIFT_JIS, JOHAB encodings, because \xe0\x7d is a single character in these
123 encodings. */
124 static void
find_variables(const char * string,void (* callback)(const char * var_ptr,size_t var_len))125 find_variables (const char *string,
126 void (*callback) (const char *var_ptr, size_t var_len))
127 {
128 for (; *string != '\0';)
129 if (*string++ == '$')
130 {
131 const char *variable_start;
132 const char *variable_end;
133 unsigned short int valid;
134 char c;
135
136 if (*string == '{')
137 string++;
138
139 variable_start = string;
140 c = *string;
141 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
142 {
143 do
144 c = *++string;
145 while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
146 || (c >= '0' && c <= '9') || c == '_');
147 variable_end = string;
148
149 if (variable_start[-1] == '{')
150 {
151 if (*string == '}')
152 {
153 string++;
154 valid = 1;
155 }
156 else
157 valid = 0;
158 }
159 else
160 valid = 1;
161
162 if (valid)
163 callback (variable_start, variable_end - variable_start);
164 }
165 }
166 }
167
168
169 /* Print a variable to stdout, followed by a newline. */
170 static void
print_variable(const char * var_ptr,size_t var_len)171 print_variable (const char *var_ptr, size_t var_len)
172 {
173 fwrite (var_ptr, var_len, 1, stdout);
174 putchar ('\n');
175 }
176
177 /* Print the variables contained in STRING to stdout, each one followed by a
178 newline. */
179 static void
print_variables(const char * string)180 print_variables (const char *string)
181 {
182 find_variables (string, &print_variable);
183 }
184
185
186 /* Type describing list of immutable strings,
187 implemented using a dynamic array. */
188 typedef struct string_list_ty string_list_ty;
189 struct string_list_ty
190 {
191 const char **item;
192 size_t nitems;
193 size_t nitems_max;
194 };
195
196 /* Initialize an empty list of strings. */
197 static inline void
string_list_init(string_list_ty * slp)198 string_list_init (string_list_ty *slp)
199 {
200 slp->item = NULL;
201 slp->nitems = 0;
202 slp->nitems_max = 0;
203 }
204
205 /* Append a single string to the end of a list of strings. */
206 static inline void
string_list_append(string_list_ty * slp,const char * s)207 string_list_append (string_list_ty *slp, const char *s)
208 {
209 /* Grow the list. */
210 if (slp->nitems >= slp->nitems_max)
211 {
212 slp->nitems_max = slp->nitems_max * 2 + 4;
213 REALLOC_ARRAY(slp->item, slp->nitems_max);
214 }
215
216 /* Add the string to the end of the list. */
217 slp->item[slp->nitems++] = s;
218 }
219
220 /* Compare two strings given by reference. */
221 static int
cmp_string(const void * pstr1,const void * pstr2)222 cmp_string (const void *pstr1, const void *pstr2)
223 {
224 const char *str1 = *(const char **)pstr1;
225 const char *str2 = *(const char **)pstr2;
226
227 return strcmp (str1, str2);
228 }
229
230 /* Sort a list of strings. */
231 static inline void
string_list_sort(string_list_ty * slp)232 string_list_sort (string_list_ty *slp)
233 {
234 QSORT(slp->item, slp->nitems, cmp_string);
235 }
236
237 /* Test whether a sorted string list contains a given string. */
238 static int
sorted_string_list_member(const string_list_ty * slp,const char * s)239 sorted_string_list_member (const string_list_ty *slp, const char *s)
240 {
241 size_t j1, j2;
242
243 j1 = 0;
244 j2 = slp->nitems;
245 if (j2 > 0)
246 {
247 /* Binary search. */
248 while (j2 - j1 > 1)
249 {
250 /* Here we know that if s is in the list, it is at an index j
251 with j1 <= j < j2. */
252 size_t j = j1 + ((j2 - j1) >> 1);
253 int result = strcmp (slp->item[j], s);
254
255 if (result > 0)
256 j2 = j;
257 else if (result == 0)
258 return 1;
259 else
260 j1 = j + 1;
261 }
262 if (j2 > j1)
263 if (strcmp (slp->item[j1], s) == 0)
264 return 1;
265 }
266 return 0;
267 }
268
269
270 /* Set of variables on which to perform substitution.
271 Used only if !all_variables. */
272 static string_list_ty variables_set;
273
274 /* Adds a variable to variables_set. */
275 static void
note_variable(const char * var_ptr,size_t var_len)276 note_variable (const char *var_ptr, size_t var_len)
277 {
278 char *string = xmemdupz (var_ptr, var_len);
279
280 string_list_append (&variables_set, string);
281 }
282
283 /* Stores the variables occurring in the string in variables_set. */
284 static void
note_variables(const char * string)285 note_variables (const char *string)
286 {
287 string_list_init (&variables_set);
288 find_variables (string, ¬e_variable);
289 string_list_sort (&variables_set);
290 }
291
292
293 static int
do_getc(void)294 do_getc (void)
295 {
296 int c = getc (stdin);
297
298 if (c == EOF)
299 {
300 if (ferror (stdin))
301 error ("error while reading standard input");
302 }
303
304 return c;
305 }
306
307 static inline void
do_ungetc(int c)308 do_ungetc (int c)
309 {
310 if (c != EOF)
311 ungetc (c, stdin);
312 }
313
314 /* Copies stdin to stdout, performing substitutions. */
315 static void
subst_from_stdin(void)316 subst_from_stdin (void)
317 {
318 static char *buffer;
319 static size_t bufmax;
320 static size_t buflen;
321 int c;
322
323 for (;;)
324 {
325 c = do_getc ();
326 if (c == EOF)
327 break;
328 /* Look for $VARIABLE or ${VARIABLE}. */
329 if (c == '$')
330 {
331 unsigned short int opening_brace = 0;
332 unsigned short int closing_brace = 0;
333
334 c = do_getc ();
335 if (c == '{')
336 {
337 opening_brace = 1;
338 c = do_getc ();
339 }
340 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
341 {
342 unsigned short int valid;
343
344 /* Accumulate the VARIABLE in buffer. */
345 buflen = 0;
346 do
347 {
348 if (buflen >= bufmax)
349 {
350 bufmax = 2 * bufmax + 10;
351 buffer = xrealloc (buffer, bufmax);
352 }
353 buffer[buflen++] = c;
354
355 c = do_getc ();
356 }
357 while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
358 || (c >= '0' && c <= '9') || c == '_');
359
360 if (opening_brace)
361 {
362 if (c == '}')
363 {
364 closing_brace = 1;
365 valid = 1;
366 }
367 else
368 {
369 valid = 0;
370 do_ungetc (c);
371 }
372 }
373 else
374 {
375 valid = 1;
376 do_ungetc (c);
377 }
378
379 if (valid)
380 {
381 /* Terminate the variable in the buffer. */
382 if (buflen >= bufmax)
383 {
384 bufmax = 2 * bufmax + 10;
385 buffer = xrealloc (buffer, bufmax);
386 }
387 buffer[buflen] = '\0';
388
389 /* Test whether the variable shall be substituted. */
390 if (!all_variables
391 && !sorted_string_list_member (&variables_set, buffer))
392 valid = 0;
393 }
394
395 if (valid)
396 {
397 /* Substitute the variable's value from the environment. */
398 const char *env_value = getenv (buffer);
399
400 if (env_value != NULL)
401 fputs (env_value, stdout);
402 }
403 else
404 {
405 /* Perform no substitution at all. Since the buffered input
406 contains no other '$' than at the start, we can just
407 output all the buffered contents. */
408 putchar ('$');
409 if (opening_brace)
410 putchar ('{');
411 fwrite (buffer, buflen, 1, stdout);
412 if (closing_brace)
413 putchar ('}');
414 }
415 }
416 else
417 {
418 do_ungetc (c);
419 putchar ('$');
420 if (opening_brace)
421 putchar ('{');
422 }
423 }
424 else
425 putchar (c);
426 }
427 }
428