1/*-
2 * Copyright (c) 2008 Joerg Sonnenberger
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "bsdtar_platform.h"
27__FBSDID("$FreeBSD: src/usr.bin/tar/subst.c,v 1.4 2008/06/15 10:08:16 kientzle Exp $");
28
29#if HAVE_REGEX_H
30#include "bsdtar.h"
31
32#include <errno.h>
33#include <regex.h>
34#include <stdlib.h>
35#include <string.h>
36
37#ifndef REG_BASIC
38#define	REG_BASIC 0
39#endif
40
41#include "err.h"
42
43struct subst_rule {
44	struct subst_rule *next;
45	regex_t re;
46	char *result;
47	unsigned int global:1, print:1, symlink:1;
48};
49
50struct substitution {
51	struct subst_rule *first_rule, *last_rule;
52};
53
54static void
55init_substitution(struct bsdtar *bsdtar)
56{
57	struct substitution *subst;
58
59	bsdtar->substitution = subst = malloc(sizeof(*subst));
60	if (subst == NULL)
61		lafe_errc(1, errno, "Out of memory");
62	subst->first_rule = subst->last_rule = NULL;
63}
64
65void
66add_substitution(struct bsdtar *bsdtar, const char *rule_text)
67{
68	struct subst_rule *rule;
69	struct substitution *subst;
70	const char *end_pattern, *start_subst;
71	char *pattern;
72	int r;
73
74	if ((subst = bsdtar->substitution) == NULL) {
75		init_substitution(bsdtar);
76		subst = bsdtar->substitution;
77	}
78
79	rule = malloc(sizeof(*rule));
80	if (rule == NULL)
81		lafe_errc(1, errno, "Out of memory");
82	rule->next = NULL;
83
84	if (subst->last_rule == NULL)
85		subst->first_rule = rule;
86	else
87		subst->last_rule->next = rule;
88	subst->last_rule = rule;
89
90	if (*rule_text == '\0')
91		lafe_errc(1, 0, "Empty replacement string");
92	end_pattern = strchr(rule_text + 1, *rule_text);
93	if (end_pattern == NULL)
94		lafe_errc(1, 0, "Invalid replacement string");
95
96	pattern = malloc(end_pattern - rule_text);
97	if (pattern == NULL)
98		lafe_errc(1, errno, "Out of memory");
99	memcpy(pattern, rule_text + 1, end_pattern - rule_text - 1);
100	pattern[end_pattern - rule_text - 1] = '\0';
101
102	if ((r = regcomp(&rule->re, pattern, REG_BASIC)) != 0) {
103		char buf[80];
104		regerror(r, &rule->re, buf, sizeof(buf));
105		lafe_errc(1, 0, "Invalid regular expression: %s", buf);
106	}
107	free(pattern);
108
109	start_subst = end_pattern + 1;
110	end_pattern = strchr(start_subst, *rule_text);
111	if (end_pattern == NULL)
112		lafe_errc(1, 0, "Invalid replacement string");
113
114	rule->result = malloc(end_pattern - start_subst + 1);
115	if (rule->result == NULL)
116		lafe_errc(1, errno, "Out of memory");
117	memcpy(rule->result, start_subst, end_pattern - start_subst);
118	rule->result[end_pattern - start_subst] = '\0';
119
120	rule->global = 0;
121	rule->print = 0;
122	rule->symlink = 0;
123
124	while (*++end_pattern) {
125		switch (*end_pattern) {
126		case 'g':
127		case 'G':
128			rule->global = 1;
129			break;
130		case 'p':
131		case 'P':
132			rule->print = 1;
133			break;
134		case 's':
135		case 'S':
136			rule->symlink = 1;
137			break;
138		default:
139			lafe_errc(1, 0, "Invalid replacement flag %c", *end_pattern);
140		}
141	}
142}
143
144static void
145realloc_strncat(char **str, const char *append, size_t len)
146{
147	char *new_str;
148	size_t old_len;
149
150	if (*str == NULL)
151		old_len = 0;
152	else
153		old_len = strlen(*str);
154
155	new_str = malloc(old_len + len + 1);
156	if (new_str == NULL)
157		lafe_errc(1, errno, "Out of memory");
158	memcpy(new_str, *str, old_len);
159	memcpy(new_str + old_len, append, len);
160	new_str[old_len + len] = '\0';
161	free(*str);
162	*str = new_str;
163}
164
165static void
166realloc_strcat(char **str, const char *append)
167{
168	char *new_str;
169	size_t old_len;
170
171	if (*str == NULL)
172		old_len = 0;
173	else
174		old_len = strlen(*str);
175
176	new_str = malloc(old_len + strlen(append) + 1);
177	if (new_str == NULL)
178		lafe_errc(1, errno, "Out of memory");
179	memcpy(new_str, *str, old_len);
180	strcpy(new_str + old_len, append);
181	free(*str);
182	*str = new_str;
183}
184
185int
186apply_substitution(struct bsdtar *bsdtar, const char *name, char **result, int symlink_only)
187{
188	const char *path = name;
189	regmatch_t matches[10];
190	size_t i, j;
191	struct subst_rule *rule;
192	struct substitution *subst;
193	int c, got_match, print_match;
194
195	*result = NULL;
196
197	if ((subst = bsdtar->substitution) == NULL)
198		return 0;
199
200	got_match = 0;
201	print_match = 0;
202
203	for (rule = subst->first_rule; rule != NULL; rule = rule->next) {
204		if (symlink_only && !rule->symlink)
205			continue;
206		if (regexec(&rule->re, name, 10, matches, 0))
207			continue;
208
209		got_match = 1;
210		print_match |= rule->print;
211		realloc_strncat(result, name, matches[0].rm_so);
212
213		for (i = 0, j = 0; rule->result[i] != '\0'; ++i) {
214			if (rule->result[i] == '~') {
215				realloc_strncat(result, rule->result + j, i - j);
216				realloc_strncat(result, name, matches[0].rm_eo);
217				j = i + 1;
218				continue;
219			}
220			if (rule->result[i] != '\\')
221				continue;
222
223			++i;
224			c = rule->result[i];
225			switch (c) {
226			case '~':
227			case '\\':
228				realloc_strncat(result, rule->result + j, i - j - 1);
229				j = i;
230				break;
231			case '1':
232			case '2':
233			case '3':
234			case '4':
235			case '5':
236			case '6':
237			case '7':
238			case '8':
239			case '9':
240				realloc_strncat(result, rule->result + j, i - j - 1);
241				if ((size_t)(c - '0') > (size_t)(rule->re.re_nsub)) {
242					free(*result);
243					*result = NULL;
244					return -1;
245				}
246				realloc_strncat(result, name + matches[c - '0'].rm_so, matches[c - '0'].rm_eo - matches[c - '0'].rm_so);
247				j = i + 1;
248				break;
249			default:
250				/* Just continue; */
251				break;
252			}
253
254		}
255
256		realloc_strcat(result, rule->result + j);
257
258		name += matches[0].rm_eo;
259
260		if (!rule->global)
261			break;
262	}
263
264	if (got_match)
265		realloc_strcat(result, name);
266
267	if (print_match)
268		fprintf(stderr, "%s >> %s\n", path, *result);
269
270	return got_match;
271}
272
273void
274cleanup_substitution(struct bsdtar *bsdtar)
275{
276	struct subst_rule *rule;
277	struct substitution *subst;
278
279	if ((subst = bsdtar->substitution) == NULL)
280		return;
281
282	while ((rule = subst->first_rule) != NULL) {
283		subst->first_rule = rule->next;
284		free(rule->result);
285		free(rule);
286	}
287	free(subst);
288}
289#endif /* HAVE_REGEX_H */
290