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 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 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 * 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 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 * 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 245 error_lzma_preset(const char *valuestr) 246 { 247 message_fatal(_("Unsupported LZMA1/LZMA2 preset: %s"), valuestr); 248 } 249 250 251 static void 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 * 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