1 // SPDX-License-Identifier: 0BSD
2
3 ///////////////////////////////////////////////////////////////////////////////
4 //
5 /// \file options.c
6 /// \brief Parser for filter-specific options
7 //
8 // Author: Lasse Collin
9 //
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #include "private.h"
13
14
15 ///////////////////
16 // Generic stuff //
17 ///////////////////
18
19 typedef struct {
20 const char *name;
21 uint64_t id;
22 } name_id_map;
23
24
25 typedef struct {
26 const char *name;
27 const name_id_map *map;
28 uint64_t min;
29 uint64_t max;
30 } option_map;
31
32
33 /// Parses option=value pairs that are separated with commas:
34 /// opt=val,opt=val,opt=val
35 ///
36 /// Each option is a string, that is converted to an integer using the
37 /// index where the option string is in the array.
38 ///
39 /// Value can be
40 /// - a string-id map mapping a list of possible string values to integers
41 /// (opts[i].map != NULL, opts[i].min and opts[i].max are ignored);
42 /// - a number with minimum and maximum value limit
43 /// (opts[i].map == NULL && opts[i].min != UINT64_MAX);
44 /// - a string that will be parsed by the filter-specific code
45 /// (opts[i].map == NULL && opts[i].min == UINT64_MAX, opts[i].max ignored)
46 ///
47 /// When parsing both option and value succeed, a filter-specific function
48 /// is called, which should update the given value to filter-specific
49 /// options structure.
50 ///
51 /// This returns only if no errors occur.
52 ///
53 /// \param str String containing the options from the command line
54 /// \param opts Filter-specific option map
55 /// \param set Filter-specific function to update filter_options
56 /// \param filter_options Pointer to filter-specific options structure
57 ///
58 static void
parse_options(const char * str,const option_map * opts,void (* set)(void * filter_options,unsigned key,uint64_t value,const char * valuestr),void * filter_options)59 parse_options(const char *str, const option_map *opts,
60 void (*set)(void *filter_options,
61 unsigned key, uint64_t value, const char *valuestr),
62 void *filter_options)
63 {
64 if (str == NULL || str[0] == '\0')
65 return;
66
67 char *s = xstrdup(str);
68 char *name = s;
69
70 while (*name != '\0') {
71 if (*name == ',') {
72 ++name;
73 continue;
74 }
75
76 char *split = strchr(name, ',');
77 if (split != NULL)
78 *split = '\0';
79
80 char *value = strchr(name, '=');
81 if (value != NULL)
82 *value++ = '\0';
83
84 if (value == NULL || value[0] == '\0')
85 message_fatal(_("%s: Options must be 'name=value' "
86 "pairs separated with commas"), str);
87
88 // Look for the option name from the option map.
89 unsigned i = 0;
90 while (true) {
91 if (opts[i].name == NULL)
92 message_fatal(_("%s: Invalid option name"),
93 name);
94
95 if (strcmp(name, opts[i].name) == 0)
96 break;
97
98 ++i;
99 }
100
101 // Option was found from the map. See how we should handle it.
102 if (opts[i].map != NULL) {
103 // value is a string which we should map
104 // to an integer.
105 unsigned j;
106 for (j = 0; opts[i].map[j].name != NULL; ++j) {
107 if (strcmp(opts[i].map[j].name, value) == 0)
108 break;
109 }
110
111 if (opts[i].map[j].name == NULL)
112 message_fatal(_("%s: Invalid option value"),
113 value);
114
115 set(filter_options, i, opts[i].map[j].id, value);
116
117 } else if (opts[i].min == UINT64_MAX) {
118 // value is a special string that will be
119 // parsed by set().
120 set(filter_options, i, 0, value);
121
122 } else {
123 // value is an integer.
124 const uint64_t v = str_to_uint64(name, value,
125 opts[i].min, opts[i].max);
126 set(filter_options, i, v, value);
127 }
128
129 // Check if it was the last option.
130 if (split == NULL)
131 break;
132
133 name = split + 1;
134 }
135
136 free(s);
137 return;
138 }
139
140
141 ///////////
142 // Delta //
143 ///////////
144
145 enum {
146 OPT_DIST,
147 };
148
149
150 static void
set_delta(void * options,unsigned key,uint64_t value,const char * valuestr lzma_attribute ((__unused__)))151 set_delta(void *options, unsigned key, uint64_t value,
152 const char *valuestr lzma_attribute((__unused__)))
153 {
154 lzma_options_delta *opt = options;
155 switch (key) {
156 case OPT_DIST:
157 opt->dist = value;
158 break;
159 }
160 }
161
162
163 extern lzma_options_delta *
options_delta(const char * str)164 options_delta(const char *str)
165 {
166 static const option_map opts[] = {
167 { "dist", NULL, LZMA_DELTA_DIST_MIN,
168 LZMA_DELTA_DIST_MAX },
169 { NULL, NULL, 0, 0 }
170 };
171
172 lzma_options_delta *options = xmalloc(sizeof(lzma_options_delta));
173 *options = (lzma_options_delta){
174 // It's hard to give a useful default for this.
175 .type = LZMA_DELTA_TYPE_BYTE,
176 .dist = LZMA_DELTA_DIST_MIN,
177 };
178
179 parse_options(str, opts, &set_delta, options);
180
181 return options;
182 }
183
184
185 /////////
186 // BCJ //
187 /////////
188
189 enum {
190 OPT_START_OFFSET,
191 };
192
193
194 static void
set_bcj(void * options,unsigned key,uint64_t value,const char * valuestr lzma_attribute ((__unused__)))195 set_bcj(void *options, unsigned key, uint64_t value,
196 const char *valuestr lzma_attribute((__unused__)))
197 {
198 lzma_options_bcj *opt = options;
199 switch (key) {
200 case OPT_START_OFFSET:
201 opt->start_offset = value;
202 break;
203 }
204 }
205
206
207 extern lzma_options_bcj *
options_bcj(const char * str)208 options_bcj(const char *str)
209 {
210 static const option_map opts[] = {
211 { "start", NULL, 0, UINT32_MAX },
212 { NULL, NULL, 0, 0 }
213 };
214
215 lzma_options_bcj *options = xmalloc(sizeof(lzma_options_bcj));
216 *options = (lzma_options_bcj){
217 .start_offset = 0,
218 };
219
220 parse_options(str, opts, &set_bcj, options);
221
222 return options;
223 }
224
225
226 //////////
227 // LZMA //
228 //////////
229
230 enum {
231 OPT_PRESET,
232 OPT_DICT,
233 OPT_LC,
234 OPT_LP,
235 OPT_PB,
236 OPT_MODE,
237 OPT_NICE,
238 OPT_MF,
239 OPT_DEPTH,
240 };
241
242
243 tuklib_attr_noreturn
244 static void
error_lzma_preset(const char * valuestr)245 error_lzma_preset(const char *valuestr)
246 {
247 message_fatal(_("Unsupported LZMA1/LZMA2 preset: %s"), valuestr);
248 }
249
250
251 static void
set_lzma(void * options,unsigned key,uint64_t value,const char * valuestr)252 set_lzma(void *options, unsigned key, uint64_t value, const char *valuestr)
253 {
254 lzma_options_lzma *opt = options;
255
256 switch (key) {
257 case OPT_PRESET: {
258 if (valuestr[0] < '0' || valuestr[0] > '9')
259 error_lzma_preset(valuestr);
260
261 uint32_t preset = (uint32_t)(valuestr[0] - '0');
262
263 // Currently only "e" is supported as a modifier,
264 // so keep this simple for now.
265 if (valuestr[1] != '\0') {
266 if (valuestr[1] == 'e')
267 preset |= LZMA_PRESET_EXTREME;
268 else
269 error_lzma_preset(valuestr);
270
271 if (valuestr[2] != '\0')
272 error_lzma_preset(valuestr);
273 }
274
275 if (lzma_lzma_preset(options, preset))
276 error_lzma_preset(valuestr);
277
278 break;
279 }
280
281 case OPT_DICT:
282 opt->dict_size = value;
283 break;
284
285 case OPT_LC:
286 opt->lc = value;
287 break;
288
289 case OPT_LP:
290 opt->lp = value;
291 break;
292
293 case OPT_PB:
294 opt->pb = value;
295 break;
296
297 case OPT_MODE:
298 opt->mode = value;
299 break;
300
301 case OPT_NICE:
302 opt->nice_len = value;
303 break;
304
305 case OPT_MF:
306 opt->mf = value;
307 break;
308
309 case OPT_DEPTH:
310 opt->depth = value;
311 break;
312 }
313 }
314
315
316 extern lzma_options_lzma *
options_lzma(const char * str)317 options_lzma(const char *str)
318 {
319 static const name_id_map modes[] = {
320 { "fast", LZMA_MODE_FAST },
321 { "normal", LZMA_MODE_NORMAL },
322 { NULL, 0 }
323 };
324
325 static const name_id_map mfs[] = {
326 { "hc3", LZMA_MF_HC3 },
327 { "hc4", LZMA_MF_HC4 },
328 { "bt2", LZMA_MF_BT2 },
329 { "bt3", LZMA_MF_BT3 },
330 { "bt4", LZMA_MF_BT4 },
331 { NULL, 0 }
332 };
333
334 static const option_map opts[] = {
335 { "preset", NULL, UINT64_MAX, 0 },
336 { "dict", NULL, LZMA_DICT_SIZE_MIN,
337 (UINT32_C(1) << 30) + (UINT32_C(1) << 29) },
338 { "lc", NULL, LZMA_LCLP_MIN, LZMA_LCLP_MAX },
339 { "lp", NULL, LZMA_LCLP_MIN, LZMA_LCLP_MAX },
340 { "pb", NULL, LZMA_PB_MIN, LZMA_PB_MAX },
341 { "mode", modes, 0, 0 },
342 { "nice", NULL, 2, 273 },
343 { "mf", mfs, 0, 0 },
344 { "depth", NULL, 0, UINT32_MAX },
345 { NULL, NULL, 0, 0 }
346 };
347
348 lzma_options_lzma *options = xmalloc(sizeof(lzma_options_lzma));
349 if (lzma_lzma_preset(options, LZMA_PRESET_DEFAULT))
350 message_bug();
351
352 parse_options(str, opts, &set_lzma, options);
353
354 if (options->lc + options->lp > LZMA_LCLP_MAX)
355 message_fatal(_("The sum of lc and lp must not exceed 4"));
356
357 return options;
358 }
359