Whamcloud - gitweb
LU-8998 debugfs: handle combined LMA EA and PFID EA
[tools/e2fsprogs.git] / util / subst.c
1 /*
2  * subst.c --- substitution program
3  *
4  * Subst is used as a quicky program to do @ substitutions
5  *
6  */
7
8 #ifdef HAVE_CONFIG_H
9 #include "config.h"
10 #else
11 #define HAVE_SYS_TIME_H
12 #endif
13 #include <stdio.h>
14 #include <errno.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <string.h>
18 #include <ctype.h>
19 #ifdef HAVE_SYS_TIME_H
20 #include <sys/time.h>
21 #endif
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <fcntl.h>
25 #include <time.h>
26 #include <utime.h>
27
28 #ifdef HAVE_GETOPT_H
29 #include <getopt.h>
30 #else
31 extern char *optarg;
32 extern int optind;
33 #endif
34
35
36 struct subst_entry {
37         char *name;
38         char *value;
39         struct subst_entry *next;
40 };
41
42 static struct subst_entry *subst_table = 0;
43
44 static int add_subst(char *name, char *value)
45 {
46         struct subst_entry      *ent = 0;
47
48         ent = (struct subst_entry *) malloc(sizeof(struct subst_entry));
49         if (!ent)
50                 goto fail;
51         ent->name = (char *) malloc(strlen(name)+1);
52         if (!ent->name)
53                 goto fail;
54         ent->value = (char *) malloc(strlen(value)+1);
55         if (!ent->value)
56                 goto fail;
57         strcpy(ent->name, name);
58         strcpy(ent->value, value);
59         ent->next = subst_table;
60         subst_table = ent;
61         return 0;
62 fail:
63         if (ent) {
64                 free(ent->name);
65                 free(ent);
66         }
67         return ENOMEM;
68 }
69
70 static struct subst_entry *fetch_subst_entry(char *name)
71 {
72         struct subst_entry *ent;
73
74         for (ent = subst_table; ent; ent = ent->next) {
75                 if (strcmp(name, ent->name) == 0)
76                         break;
77         }
78         return ent;
79 }
80
81 /*
82  * Given the starting and ending position of the replacement name,
83  * check to see if it is valid, and pull it out if it is.
84  */
85 static char *get_subst_symbol(const char *begin, size_t len, char prefix)
86 {
87         static char replace_name[128];
88         char *cp, *start;
89
90         start = replace_name;
91         if (prefix)
92                 *start++ = prefix;
93
94         if (len > sizeof(replace_name)-2)
95                 return NULL;
96         memcpy(start, begin, len);
97         start[len] = 0;
98
99         /*
100          * The substitution variable must all be in the of [0-9A-Za-z_].
101          * If it isn't, this must be an invalid symbol name.
102          */
103         for (cp = start; *cp; cp++) {
104                 if (!(*cp >= 'a' && *cp <= 'z') &&
105                     !(*cp >= 'A' && *cp <= 'Z') &&
106                     !(*cp >= '0' && *cp <= '9') &&
107                     !(*cp == '_'))
108                         return NULL;
109         }
110         return (replace_name);
111 }
112
113 static void replace_string(char *begin, char *end, char *newstr)
114 {
115         int     replace_len, len;
116
117         replace_len = strlen(newstr);
118         len = end - begin;
119         if (replace_len == 0)
120                 memmove(begin, end+1, strlen(end)+1);
121         else if (replace_len != len+1)
122                 memmove(end+(replace_len-len-1), end,
123                         strlen(end)+1);
124         memcpy(begin, newstr, replace_len);
125 }
126
127 static void substitute_line(char *line)
128 {
129         char    *ptr, *name_ptr, *end_ptr;
130         struct subst_entry *ent;
131         char    *replace_name;
132         size_t  len;
133
134         /*
135          * Expand all @FOO@ substitutions
136          */
137         ptr = line;
138         while (ptr) {
139                 name_ptr = strchr(ptr, '@');
140                 if (!name_ptr)
141                         break;  /* No more */
142                 if (*(++name_ptr) == '@') {
143                         /*
144                          * Handle tytso@@mit.edu --> tytso@mit.edu
145                          */
146                         memmove(name_ptr-1, name_ptr, strlen(name_ptr)+1);
147                         ptr = name_ptr+1;
148                         continue;
149                 }
150                 end_ptr = strchr(name_ptr, '@');
151                 if (!end_ptr)
152                         break;
153                 len = end_ptr - name_ptr;
154                 replace_name = get_subst_symbol(name_ptr, len, 0);
155                 if (!replace_name) {
156                         ptr = name_ptr;
157                         continue;
158                 }
159                 ent = fetch_subst_entry(replace_name);
160                 if (!ent) {
161                         fprintf(stderr, "Unfound expansion: '%s'\n",
162                                 replace_name);
163                         ptr = end_ptr + 1;
164                         continue;
165                 }
166 #if 0
167                 fprintf(stderr, "Replace name = '%s' with '%s'\n",
168                        replace_name, ent->value);
169 #endif
170                 ptr = name_ptr-1;
171                 replace_string(ptr, end_ptr, ent->value);
172                 if ((ent->value[0] == '@') &&
173                     (strlen(replace_name) == strlen(ent->value)-2) &&
174                     !strncmp(replace_name, ent->value+1,
175                              strlen(ent->value)-2))
176                         /* avoid an infinite loop */
177                         ptr += strlen(ent->value);
178         }
179         /*
180          * Now do a second pass to expand ${FOO}
181          */
182         ptr = line;
183         while (ptr) {
184                 name_ptr = strchr(ptr, '$');
185                 if (!name_ptr)
186                         break;  /* No more */
187                 if (*(++name_ptr) != '{') {
188                         ptr = name_ptr;
189                         continue;
190                 }
191                 name_ptr++;
192                 end_ptr = strchr(name_ptr, '}');
193                 if (!end_ptr)
194                         break;
195                 len = end_ptr - name_ptr;
196                 replace_name = get_subst_symbol(name_ptr, len, '$');
197                 if (!replace_name) {
198                         ptr = name_ptr;
199                         continue;
200                 }
201                 ent = fetch_subst_entry(replace_name);
202                 if (!ent) {
203                         ptr = end_ptr + 1;
204                         continue;
205                 }
206 #if 0
207                 fprintf(stderr, "Replace name = '%s' with '%s'\n",
208                        replace_name, ent->value);
209 #endif
210                 ptr = name_ptr-2;
211                 replace_string(ptr, end_ptr, ent->value);
212         }
213 }
214
215 static void parse_config_file(FILE *f)
216 {
217         char    line[2048];
218         char    *cp, *ptr;
219
220         while (!feof(f)) {
221                 memset(line, 0, sizeof(line));
222                 if (fgets(line, sizeof(line), f) == NULL)
223                         break;
224                 /*
225                  * Strip newlines and comments.
226                  */
227                 cp = strchr(line, '\n');
228                 if (cp)
229                         *cp = 0;
230                 cp = strchr(line, '#');
231                 if (cp)
232                         *cp = 0;
233                 /*
234                  * Skip trailing and leading whitespace
235                  */
236                 for (cp = line + strlen(line) - 1; cp >= line; cp--) {
237                         if (*cp == ' ' || *cp == '\t')
238                                 *cp = 0;
239                         else
240                                 break;
241                 }
242                 cp = line;
243                 while (*cp && isspace(*cp))
244                         cp++;
245                 ptr = cp;
246                 /*
247                  * Skip empty lines
248                  */
249                 if (*ptr == 0)
250                         continue;
251                 /*
252                  * Ignore future extensions
253                  */
254                 if (*ptr == '@')
255                         continue;
256                 /*
257                  * Parse substitutions
258                  */
259                 for (cp = ptr; *cp; cp++)
260                         if (isspace(*cp))
261                                 break;
262                 *cp = 0;
263                 for (cp++; *cp; cp++)
264                         if (!isspace(*cp))
265                                 break;
266 #if 0
267                 printf("Substitute: '%s' for '%s'\n", ptr, cp ? cp : "<NULL>");
268 #endif
269                 add_subst(ptr, cp);
270         }
271 }
272
273 /*
274  * Return 0 if the files are different, 1 if the files are the same.
275  */
276 static int compare_file(FILE *old_f, FILE *new_f)
277 {
278         char    oldbuf[2048], newbuf[2048], *oldcp, *newcp;
279         int     retval;
280
281         while (1) {
282                 oldcp = fgets(oldbuf, sizeof(oldbuf), old_f);
283                 newcp = fgets(newbuf, sizeof(newbuf), new_f);
284                 if (!oldcp && !newcp) {
285                         retval = 1;
286                         break;
287                 }
288                 if (!oldcp || !newcp || strcmp(oldbuf, newbuf)) {
289                         retval = 0;
290                         break;
291                 }
292         }
293         return retval;
294 }
295
296 void set_utimes(const char *filename, int fd, const struct timeval times[2])
297 {
298 #ifdef HAVE_FUTIMES
299         if (futimes(fd, times) < 0)
300                 perror("futimes");
301 #elif HAVE_UTIMES
302         if (utimes(filename, times) < 0)
303                 perror("utimes");
304 #else
305         struct utimbuf ut;
306
307         ut.actime = times[0].tv_sec;
308         ut.modtime = times[1].tv_sec;
309         if (utime(filename, &ut) < 0)
310                 perror("utime");
311 #endif
312 }
313
314
315 int main(int argc, char **argv)
316 {
317         char    line[2048];
318         int     c;
319         int     fd;
320         FILE    *in, *out, *old = NULL;
321         char    *outfn = NULL, *newfn = NULL;
322         int     verbose = 0;
323         int     adjust_timestamp = 0;
324         int     got_atime = 0;
325         struct stat stbuf;
326         struct timeval tv[2];
327
328         while ((c = getopt (argc, argv, "f:tv")) != EOF) {
329                 switch (c) {
330                 case 'f':
331                         in = fopen(optarg, "r");
332                         if (!in) {
333                                 perror(optarg);
334                                 exit(1);
335                         }
336                         parse_config_file(in);
337                         fclose(in);
338                         break;
339                 case 't':
340                         adjust_timestamp++;
341                         break;
342                 case 'v':
343                         verbose++;
344                         break;
345                 default:
346                         fprintf(stderr, "%s: [-f config-file] [file]\n",
347                                 argv[0]);
348                         break;
349                 }
350         }
351         if (optind < argc) {
352                 in = fopen(argv[optind], "r");
353                 if (!in) {
354                         perror(argv[optind]);
355                         exit(1);
356                 }
357                 optind++;
358         } else
359                 in = stdin;
360
361         if (optind < argc) {
362                 outfn = argv[optind];
363                 newfn = (char *) malloc(strlen(outfn)+20);
364                 if (!newfn) {
365                         fprintf(stderr, "Memory error!  Exiting.\n");
366                         exit(1);
367                 }
368                 strcpy(newfn, outfn);
369                 strcat(newfn, ".new");
370                 fd = open(newfn, O_CREAT|O_TRUNC|O_RDWR, 0444);
371                 if (fd < 0) {
372                         perror(newfn);
373                         exit(1);
374                 }
375                 out = fdopen(fd, "w+");
376                 if (!out) {
377                         perror("fdopen");
378                         exit(1);
379                 }
380
381                 fd = open(outfn, O_RDONLY);
382                 if (fd > 0) {
383                         /* save the original atime, if possible */
384                         if (fstat(fd, &stbuf) == 0) {
385 #if HAVE_STRUCT_STAT_ST_ATIM
386                                 tv[0].tv_sec = stbuf.st_atim.tv_sec;
387                                 tv[0].tv_usec = stbuf.st_atim.tv_nsec / 1000;
388 #else
389                                 tv[0].tv_sec = stbuf.st_atime;
390                                 tv[0].tv_usec = 0;
391 #endif
392                                 got_atime = 1;
393                         }
394                         old = fdopen(fd, "r");
395                         if (!old)
396                                 close(fd);
397                 }
398         } else {
399                 out = stdout;
400                 outfn = 0;
401         }
402
403         while (!feof(in)) {
404                 if (fgets(line, sizeof(line), in) == NULL)
405                         break;
406                 substitute_line(line);
407                 fputs(line, out);
408         }
409         fclose(in);
410         if (outfn) {
411                 fflush(out);
412                 rewind(out);
413                 if (old && compare_file(old, out)) {
414                         if (verbose)
415                                 printf("No change, keeping %s.\n", outfn);
416                         if (adjust_timestamp) {
417                                 if (verbose)
418                                         printf("Updating modtime for %s\n", outfn);
419                                 if (gettimeofday(&tv[1], NULL) < 0) {
420                                         perror("gettimeofday");
421                                         exit(1);
422                                 }
423                                 if (got_atime == 0)
424                                         tv[0] = tv[1];
425                                 else if (verbose)
426                                         printf("Using original atime\n");
427                                 set_utimes(outfn, fileno(old), tv);
428                         }
429                         fclose(out);
430                         if (unlink(newfn) < 0)
431                                 perror("unlink");
432                 } else {
433                         if (verbose)
434                                 printf("Creating or replacing %s.\n", outfn);
435                         fclose(out);
436                         if (old)
437                                 fclose(old);
438                         old = NULL;
439                         if (rename(newfn, outfn) < 0) {
440                                 perror("rename");
441                                 exit(1);
442                         }
443                 }
444         }
445         if (old)
446                 fclose(old);
447         return (0);
448 }
449
450