flac/metaflac: Do case-insensitve comparison of hex values
[flac.git] / src / metaflac / options.c
1 /* metaflac - Command-line FLAC metadata editor
2  * Copyright (C) 2001-2009  Josh Coalson
3  * Copyright (C) 2011-2014  Xiph.Org Foundation
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include <config.h>
22 #endif
23
24 #include "options.h"
25 #include "usage.h"
26 #include "utils.h"
27 #include "FLAC/assert.h"
28 #include "share/alloc.h"
29 #include "share/compat.h"
30 #include "share/grabbag/replaygain.h"
31 #include <ctype.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 /*
37    share__getopt format struct; note we don't use short options so we just
38    set the 'val' field to 0 everywhere to indicate a valid option.
39 */
40 struct share__option long_options_[] = {
41         /* global options */
42         { "preserve-modtime", 0, 0, 0 },
43         { "with-filename", 0, 0, 0 },
44         { "no-filename", 0, 0, 0 },
45         { "no-utf8-convert", 0, 0, 0 },
46         { "dont-use-padding", 0, 0, 0 },
47         { "no-cued-seekpoints", 0, 0, 0 },
48         /* shorthand operations */
49         { "show-md5sum", 0, 0, 0 },
50         { "show-min-blocksize", 0, 0, 0 },
51         { "show-max-blocksize", 0, 0, 0 },
52         { "show-min-framesize", 0, 0, 0 },
53         { "show-max-framesize", 0, 0, 0 },
54         { "show-sample-rate", 0, 0, 0 },
55         { "show-channels", 0, 0, 0 },
56         { "show-bps", 0, 0, 0 },
57         { "show-total-samples", 0, 0, 0 },
58         { "set-md5sum", 1, 0, 0 }, /* undocumented */
59         { "set-min-blocksize", 1, 0, 0 }, /* undocumented */
60         { "set-max-blocksize", 1, 0, 0 }, /* undocumented */
61         { "set-min-framesize", 1, 0, 0 }, /* undocumented */
62         { "set-max-framesize", 1, 0, 0 }, /* undocumented */
63         { "set-sample-rate", 1, 0, 0 }, /* undocumented */
64         { "set-channels", 1, 0, 0 }, /* undocumented */
65         { "set-bps", 1, 0, 0 }, /* undocumented */
66         { "set-total-samples", 1, 0, 0 }, /* undocumented */ /* WATCHOUT: used by test/test_flac.sh on windows */
67         { "show-vendor-tag", 0, 0, 0 },
68         { "show-tag", 1, 0, 0 },
69         { "remove-all-tags", 0, 0, 0 },
70         { "remove-tag", 1, 0, 0 },
71         { "remove-first-tag", 1, 0, 0 },
72         { "set-tag", 1, 0, 0 },
73         { "set-tag-from-file", 1, 0, 0 },
74         { "import-tags-from", 1, 0, 0 },
75         { "export-tags-to", 1, 0, 0 },
76         { "import-cuesheet-from", 1, 0, 0 },
77         { "export-cuesheet-to", 1, 0, 0 },
78         { "import-picture-from", 1, 0, 0 },
79         { "export-picture-to", 1, 0, 0 },
80         { "add-seekpoint", 1, 0, 0 },
81         { "add-replay-gain", 0, 0, 0 },
82         { "remove-replay-gain", 0, 0, 0 },
83         { "add-padding", 1, 0, 0 },
84         /* major operations */
85         { "help", 0, 0, 0 },
86         { "version", 0, 0, 0 },
87         { "list", 0, 0, 0 },
88         { "append", 0, 0, 0 },
89         { "remove", 0, 0, 0 },
90         { "remove-all", 0, 0, 0 },
91         { "merge-padding", 0, 0, 0 },
92         { "sort-padding", 0, 0, 0 },
93         /* major operation arguments */
94         { "block-number", 1, 0, 0 },
95         { "block-type", 1, 0, 0 },
96         { "except-block-type", 1, 0, 0 },
97         { "data-format", 1, 0, 0 },
98         { "application-data-format", 1, 0, 0 },
99         { "from-file", 1, 0, 0 },
100         {0, 0, 0, 0}
101 };
102
103 static FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options);
104 static void append_new_operation(CommandLineOptions *options, Operation operation);
105 static void append_new_argument(CommandLineOptions *options, Argument argument);
106 static Operation *append_major_operation(CommandLineOptions *options, OperationType type);
107 static Operation *append_shorthand_operation(CommandLineOptions *options, OperationType type);
108 static Argument *find_argument(CommandLineOptions *options, ArgumentType type);
109 static Operation *find_shorthand_operation(CommandLineOptions *options, OperationType type);
110 static Argument *append_argument(CommandLineOptions *options, ArgumentType type);
111 static FLAC__bool parse_md5(const char *src, FLAC__byte dest[16]);
112 static FLAC__bool parse_uint32(const char *src, FLAC__uint32 *dest);
113 static FLAC__bool parse_uint64(const char *src, FLAC__uint64 *dest);
114 static FLAC__bool parse_string(const char *src, char **dest);
115 static FLAC__bool parse_vorbis_comment_field_name(const char *field_ref, char **name, const char **violation);
116 static FLAC__bool parse_add_seekpoint(const char *in, char **out, const char **violation);
117 static FLAC__bool parse_add_padding(const char *in, unsigned *out);
118 static FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out);
119 static FLAC__bool parse_block_type(const char *in, Argument_BlockType *out);
120 static FLAC__bool parse_data_format(const char *in, Argument_DataFormat *out);
121 static FLAC__bool parse_application_data_format(const char *in, FLAC__bool *out);
122 static void undocumented_warning(const char *opt);
123
124
125 void init_options(CommandLineOptions *options)
126 {
127         options->preserve_modtime = false;
128
129         /* '2' is a hack to mean "use default if not forced on command line" */
130         FLAC__ASSERT(true != 2);
131         options->prefix_with_filename = 2;
132
133         options->utf8_convert = true;
134         options->use_padding = true;
135         options->cued_seekpoints = true;
136         options->show_long_help = false;
137         options->show_version = false;
138         options->application_data_format_is_hexdump = false;
139
140         options->ops.operations = 0;
141         options->ops.num_operations = 0;
142         options->ops.capacity = 0;
143
144         options->args.arguments = 0;
145         options->args.num_arguments = 0;
146         options->args.capacity = 0;
147
148         options->args.checks.num_shorthand_ops = 0;
149         options->args.checks.num_major_ops = 0;
150         options->args.checks.has_block_type = false;
151         options->args.checks.has_except_block_type = false;
152
153         options->num_files = 0;
154         options->filenames = 0;
155 }
156
157 FLAC__bool parse_options(int argc, char *argv[], CommandLineOptions *options)
158 {
159         int ret;
160         int option_index = 1;
161         FLAC__bool had_error = false;
162
163         while ((ret = share__getopt_long(argc, argv, "", long_options_, &option_index)) != -1) {
164                 switch (ret) {
165                         case 0:
166                                 had_error |= !parse_option(option_index, share__optarg, options);
167                                 break;
168                         case '?':
169                         case ':':
170                                 had_error = true;
171                                 break;
172                         default:
173                                 FLAC__ASSERT(0);
174                                 break;
175                 }
176         }
177
178         if(options->prefix_with_filename == 2)
179                 options->prefix_with_filename = (argc - share__optind > 1);
180
181         if(share__optind >= argc && !options->show_long_help && !options->show_version) {
182                 flac_fprintf(stderr,"ERROR: you must specify at least one FLAC file;\n");
183                 flac_fprintf(stderr,"       metaflac cannot be used as a pipe\n");
184                 had_error = true;
185         }
186
187         options->num_files = argc - share__optind;
188
189         if(options->num_files > 0) {
190                 unsigned i = 0;
191                 if(0 == (options->filenames = safe_malloc_mul_2op_(sizeof(char*), /*times*/options->num_files)))
192                         die("out of memory allocating space for file names list");
193                 while(share__optind < argc)
194                         options->filenames[i++] = local_strdup(argv[share__optind++]);
195         }
196
197         if(options->args.checks.num_major_ops > 0) {
198                 if(options->args.checks.num_major_ops > 1) {
199                         flac_fprintf(stderr, "ERROR: you may only specify one major operation at a time\n");
200                         had_error = true;
201                 }
202                 else if(options->args.checks.num_shorthand_ops > 0) {
203                         flac_fprintf(stderr, "ERROR: you may not mix shorthand and major operations\n");
204                         had_error = true;
205                 }
206         }
207
208         /* check for only one FLAC file used with certain options */
209         if(options->num_files > 1) {
210                 if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
211                         flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--import-cuesheet-from'\n");
212                         had_error = true;
213                 }
214                 if(0 != find_shorthand_operation(options, OP__EXPORT_CUESHEET_TO)) {
215                         flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--export-cuesheet-to'\n");
216                         had_error = true;
217                 }
218                 if(0 != find_shorthand_operation(options, OP__EXPORT_PICTURE_TO)) {
219                         flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--export-picture-to'\n");
220                         had_error = true;
221                 }
222                 if(
223                         0 != find_shorthand_operation(options, OP__IMPORT_VC_FROM) &&
224                         0 == strcmp(find_shorthand_operation(options, OP__IMPORT_VC_FROM)->argument.filename.value, "-")
225                 ) {
226                         flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--import-tags-from=-'\n");
227                         had_error = true;
228                 }
229         }
230
231         if(options->args.checks.has_block_type && options->args.checks.has_except_block_type) {
232                 flac_fprintf(stderr, "ERROR: you may not specify both '--block-type' and '--except-block-type'\n");
233                 had_error = true;
234         }
235
236         if(had_error)
237                 short_usage(0);
238
239         /*
240          * We need to create an OP__ADD_SEEKPOINT operation if there is
241          * not one already, and --import-cuesheet-from was specified but
242          * --no-cued-seekpoints was not:
243          */
244         if(options->cued_seekpoints) {
245                 Operation *op = find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
246                 if(0 != op) {
247                         Operation *op2 = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
248                         if(0 == op2)
249                                 op2 = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
250                         op->argument.import_cuesheet_from.add_seekpoint_link = &(op2->argument.add_seekpoint);
251                 }
252         }
253
254         return had_error;
255 }
256
257 void free_options(CommandLineOptions *options)
258 {
259         unsigned i;
260         Operation *op;
261         Argument *arg;
262
263         FLAC__ASSERT(0 == options->ops.operations || options->ops.num_operations > 0);
264         FLAC__ASSERT(0 == options->args.arguments || options->args.num_arguments > 0);
265
266         for(i = 0, op = options->ops.operations; i < options->ops.num_operations; i++, op++) {
267                 switch(op->type) {
268                         case OP__SHOW_VC_FIELD:
269                         case OP__REMOVE_VC_FIELD:
270                         case OP__REMOVE_VC_FIRSTFIELD:
271                                 if(0 != op->argument.vc_field_name.value)
272                                         free(op->argument.vc_field_name.value);
273                                 break;
274                         case OP__SET_VC_FIELD:
275                                 if(0 != op->argument.vc_field.field)
276                                         free(op->argument.vc_field.field);
277                                 if(0 != op->argument.vc_field.field_name)
278                                         free(op->argument.vc_field.field_name);
279                                 if(0 != op->argument.vc_field.field_value)
280                                         free(op->argument.vc_field.field_value);
281                                 break;
282                         case OP__IMPORT_VC_FROM:
283                         case OP__EXPORT_VC_TO:
284                         case OP__EXPORT_CUESHEET_TO:
285                                 if(0 != op->argument.filename.value)
286                                         free(op->argument.filename.value);
287                                 break;
288                         case OP__IMPORT_CUESHEET_FROM:
289                                 if(0 != op->argument.import_cuesheet_from.filename)
290                                         free(op->argument.import_cuesheet_from.filename);
291                                 break;
292                         case OP__IMPORT_PICTURE_FROM:
293                                 if(0 != op->argument.specification.value)
294                                         free(op->argument.specification.value);
295                                 break;
296                         case OP__EXPORT_PICTURE_TO:
297                                 if(0 != op->argument.export_picture_to.filename)
298                                         free(op->argument.export_picture_to.filename);
299                                 break;
300                         case OP__ADD_SEEKPOINT:
301                                 if(0 != op->argument.add_seekpoint.specification)
302                                         free(op->argument.add_seekpoint.specification);
303                                 break;
304                         default:
305                                 break;
306                 }
307         }
308
309         for(i = 0, arg = options->args.arguments; i < options->args.num_arguments; i++, arg++) {
310                 switch(arg->type) {
311                         case ARG__BLOCK_NUMBER:
312                                 if(0 != arg->value.block_number.entries)
313                                         free(arg->value.block_number.entries);
314                                 break;
315                         case ARG__BLOCK_TYPE:
316                         case ARG__EXCEPT_BLOCK_TYPE:
317                                 if(0 != arg->value.block_type.entries)
318                                         free(arg->value.block_type.entries);
319                                 break;
320                         case ARG__FROM_FILE:
321                                 if(0 != arg->value.from_file.file_name)
322                                         free(arg->value.from_file.file_name);
323                                 break;
324                         default:
325                                 break;
326                 }
327         }
328
329         if(0 != options->ops.operations)
330                 free(options->ops.operations);
331
332         if(0 != options->args.arguments)
333                 free(options->args.arguments);
334
335         if(0 != options->filenames) {
336                 for(i = 0; i < options->num_files; i++) {
337                         if(0 != options->filenames[i])
338                                 free(options->filenames[i]);
339                 }
340                 free(options->filenames);
341         }
342 }
343
344 /*
345  * local routines
346  */
347
348 FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options)
349 {
350         const char *opt = long_options_[option_index].name;
351         Operation *op;
352         Argument *arg;
353         FLAC__bool ok = true;
354
355         if(0 == strcmp(opt, "preserve-modtime")) {
356                 options->preserve_modtime = true;
357         }
358         else if(0 == strcmp(opt, "with-filename")) {
359                 options->prefix_with_filename = true;
360         }
361         else if(0 == strcmp(opt, "no-filename")) {
362                 options->prefix_with_filename = false;
363         }
364         else if(0 == strcmp(opt, "no-utf8-convert")) {
365                 options->utf8_convert = false;
366         }
367         else if(0 == strcmp(opt, "dont-use-padding")) {
368                 options->use_padding = false;
369         }
370         else if(0 == strcmp(opt, "no-cued-seekpoints")) {
371                 options->cued_seekpoints = false;
372         }
373         else if(0 == strcmp(opt, "show-md5sum")) {
374                 (void) append_shorthand_operation(options, OP__SHOW_MD5SUM);
375         }
376         else if(0 == strcmp(opt, "show-min-blocksize")) {
377                 (void) append_shorthand_operation(options, OP__SHOW_MIN_BLOCKSIZE);
378         }
379         else if(0 == strcmp(opt, "show-max-blocksize")) {
380                 (void) append_shorthand_operation(options, OP__SHOW_MAX_BLOCKSIZE);
381         }
382         else if(0 == strcmp(opt, "show-min-framesize")) {
383                 (void) append_shorthand_operation(options, OP__SHOW_MIN_FRAMESIZE);
384         }
385         else if(0 == strcmp(opt, "show-max-framesize")) {
386                 (void) append_shorthand_operation(options, OP__SHOW_MAX_FRAMESIZE);
387         }
388         else if(0 == strcmp(opt, "show-sample-rate")) {
389                 (void) append_shorthand_operation(options, OP__SHOW_SAMPLE_RATE);
390         }
391         else if(0 == strcmp(opt, "show-channels")) {
392                 (void) append_shorthand_operation(options, OP__SHOW_CHANNELS);
393         }
394         else if(0 == strcmp(opt, "show-bps")) {
395                 (void) append_shorthand_operation(options, OP__SHOW_BPS);
396         }
397         else if(0 == strcmp(opt, "show-total-samples")) {
398                 (void) append_shorthand_operation(options, OP__SHOW_TOTAL_SAMPLES);
399         }
400         else if(0 == strcmp(opt, "set-md5sum")) {
401                 op = append_shorthand_operation(options, OP__SET_MD5SUM);
402                 FLAC__ASSERT(0 != option_argument);
403                 if(!parse_md5(option_argument, op->argument.streaminfo_md5.value)) {
404                         flac_fprintf(stderr, "ERROR (--%s): bad MD5 sum\n", opt);
405                         ok = false;
406                 }
407                 else
408                         undocumented_warning(opt);
409         }
410         else if(0 == strcmp(opt, "set-min-blocksize")) {
411                 op = append_shorthand_operation(options, OP__SET_MIN_BLOCKSIZE);
412                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
413                         flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
414                         ok = false;
415                 }
416                 else
417                         undocumented_warning(opt);
418         }
419         else if(0 == strcmp(opt, "set-max-blocksize")) {
420                 op = append_shorthand_operation(options, OP__SET_MAX_BLOCKSIZE);
421                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
422                         flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
423                         ok = false;
424                 }
425                 else
426                         undocumented_warning(opt);
427         }
428         else if(0 == strcmp(opt, "set-min-framesize")) {
429                 op = append_shorthand_operation(options, OP__SET_MIN_FRAMESIZE);
430                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) {
431                         flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN);
432                         ok = false;
433                 }
434                 else
435                         undocumented_warning(opt);
436         }
437         else if(0 == strcmp(opt, "set-max-framesize")) {
438                 op = append_shorthand_operation(options, OP__SET_MAX_FRAMESIZE);
439                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) {
440                         flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN);
441                         ok = false;
442                 }
443                 else
444                         undocumented_warning(opt);
445         }
446         else if(0 == strcmp(opt, "set-sample-rate")) {
447                 op = append_shorthand_operation(options, OP__SET_SAMPLE_RATE);
448                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || !FLAC__format_sample_rate_is_valid(op->argument.streaminfo_uint32.value)) {
449                         flac_fprintf(stderr, "ERROR (--%s): invalid sample rate\n", opt);
450                         ok = false;
451                 }
452                 else
453                         undocumented_warning(opt);
454         }
455         else if(0 == strcmp(opt, "set-channels")) {
456                 op = append_shorthand_operation(options, OP__SET_CHANNELS);
457                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value > FLAC__MAX_CHANNELS) {
458                         flac_fprintf(stderr, "ERROR (--%s): value must be > 0 and <= %u\n", opt, FLAC__MAX_CHANNELS);
459                         ok = false;
460                 }
461                 else
462                         undocumented_warning(opt);
463         }
464         else if(0 == strcmp(opt, "set-bps")) {
465                 op = append_shorthand_operation(options, OP__SET_BPS);
466                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BITS_PER_SAMPLE || op->argument.streaminfo_uint32.value > FLAC__MAX_BITS_PER_SAMPLE) {
467                         flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BITS_PER_SAMPLE, FLAC__MAX_BITS_PER_SAMPLE);
468                         ok = false;
469                 }
470                 else
471                         undocumented_warning(opt);
472         }
473         else if(0 == strcmp(opt, "set-total-samples")) {
474                 op = append_shorthand_operation(options, OP__SET_TOTAL_SAMPLES);
475                 if(!parse_uint64(option_argument, &(op->argument.streaminfo_uint64.value)) || op->argument.streaminfo_uint64.value >= (((FLAC__uint64)1)<<FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) {
476                         flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN);
477                         ok = false;
478                 }
479                 else
480                         undocumented_warning(opt);
481         }
482         else if(0 == strcmp(opt, "show-vendor-tag")) {
483                 (void) append_shorthand_operation(options, OP__SHOW_VC_VENDOR);
484         }
485         else if(0 == strcmp(opt, "show-tag")) {
486                 const char *violation;
487                 op = append_shorthand_operation(options, OP__SHOW_VC_FIELD);
488                 FLAC__ASSERT(0 != option_argument);
489                 if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
490                         FLAC__ASSERT(0 != violation);
491                         flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n       %s\n", opt, option_argument, violation);
492                         ok = false;
493                 }
494         }
495         else if(0 == strcmp(opt, "remove-all-tags")) {
496                 (void) append_shorthand_operation(options, OP__REMOVE_VC_ALL);
497         }
498         else if(0 == strcmp(opt, "remove-tag")) {
499                 const char *violation;
500                 op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
501                 FLAC__ASSERT(0 != option_argument);
502                 if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
503                         FLAC__ASSERT(0 != violation);
504                         flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n       %s\n", opt, option_argument, violation);
505                         ok = false;
506                 }
507         }
508         else if(0 == strcmp(opt, "remove-first-tag")) {
509                 const char *violation;
510                 op = append_shorthand_operation(options, OP__REMOVE_VC_FIRSTFIELD);
511                 FLAC__ASSERT(0 != option_argument);
512                 if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
513                         FLAC__ASSERT(0 != violation);
514                         flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n       %s\n", opt, option_argument, violation);
515                         ok = false;
516                 }
517         }
518         else if(0 == strcmp(opt, "set-tag")) {
519                 const char *violation;
520                 op = append_shorthand_operation(options, OP__SET_VC_FIELD);
521                 FLAC__ASSERT(0 != option_argument);
522                 op->argument.vc_field.field_value_from_file = false;
523                 if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
524                         FLAC__ASSERT(0 != violation);
525                         flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n       %s\n", opt, option_argument, violation);
526                         ok = false;
527                 }
528         }
529         else if(0 == strcmp(opt, "set-tag-from-file")) {
530                 const char *violation;
531                 op = append_shorthand_operation(options, OP__SET_VC_FIELD);
532                 FLAC__ASSERT(0 != option_argument);
533                 op->argument.vc_field.field_value_from_file = true;
534                 if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
535                         FLAC__ASSERT(0 != violation);
536                         flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n       %s\n", opt, option_argument, violation);
537                         ok = false;
538                 }
539         }
540         else if(0 == strcmp(opt, "import-tags-from")) {
541                 op = append_shorthand_operation(options, OP__IMPORT_VC_FROM);
542                 FLAC__ASSERT(0 != option_argument);
543                 if(!parse_string(option_argument, &(op->argument.filename.value))) {
544                         flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
545                         ok = false;
546                 }
547         }
548         else if(0 == strcmp(opt, "export-tags-to")) {
549                 op = append_shorthand_operation(options, OP__EXPORT_VC_TO);
550                 FLAC__ASSERT(0 != option_argument);
551                 if(!parse_string(option_argument, &(op->argument.filename.value))) {
552                         flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
553                         ok = false;
554                 }
555         }
556         else if(0 == strcmp(opt, "import-cuesheet-from")) {
557                 if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
558                         flac_fprintf(stderr, "ERROR (--%s): may be specified only once\n", opt);
559                         ok = false;
560                 }
561                 op = append_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
562                 FLAC__ASSERT(0 != option_argument);
563                 if(!parse_string(option_argument, &(op->argument.import_cuesheet_from.filename))) {
564                         flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
565                         ok = false;
566                 }
567         }
568         else if(0 == strcmp(opt, "export-cuesheet-to")) {
569                 op = append_shorthand_operation(options, OP__EXPORT_CUESHEET_TO);
570                 FLAC__ASSERT(0 != option_argument);
571                 if(!parse_string(option_argument, &(op->argument.filename.value))) {
572                         flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
573                         ok = false;
574                 }
575         }
576         else if(0 == strcmp(opt, "import-picture-from")) {
577                 op = append_shorthand_operation(options, OP__IMPORT_PICTURE_FROM);
578                 FLAC__ASSERT(0 != option_argument);
579                 if(!parse_string(option_argument, &(op->argument.specification.value))) {
580                         flac_fprintf(stderr, "ERROR (--%s): missing specification\n", opt);
581                         ok = false;
582                 }
583         }
584         else if(0 == strcmp(opt, "export-picture-to")) {
585                 arg = find_argument(options, ARG__BLOCK_NUMBER);
586                 op = append_shorthand_operation(options, OP__EXPORT_PICTURE_TO);
587                 FLAC__ASSERT(0 != option_argument);
588                 if(!parse_string(option_argument, &(op->argument.export_picture_to.filename))) {
589                         flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
590                         ok = false;
591                 }
592                 op->argument.export_picture_to.block_number_link = arg? &(arg->value.block_number) : 0;
593         }
594         else if(0 == strcmp(opt, "add-seekpoint")) {
595                 const char *violation;
596                 char *spec;
597                 FLAC__ASSERT(0 != option_argument);
598                 if(!parse_add_seekpoint(option_argument, &spec, &violation)) {
599                         FLAC__ASSERT(0 != violation);
600                         flac_fprintf(stderr, "ERROR (--%s): malformed seekpoint specification \"%s\",\n       %s\n", opt, option_argument, violation);
601                         ok = false;
602                 }
603                 else {
604                         op = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
605                         if(0 == op)
606                                 op = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
607                         local_strcat(&(op->argument.add_seekpoint.specification), spec);
608                         local_strcat(&(op->argument.add_seekpoint.specification), ";");
609                         free(spec);
610                 }
611         }
612         else if(0 == strcmp(opt, "add-replay-gain")) {
613                 (void) append_shorthand_operation(options, OP__ADD_REPLAY_GAIN);
614         }
615         else if(0 == strcmp(opt, "remove-replay-gain")) {
616                 const FLAC__byte * const tags[5] = {
617                         GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS,
618                         GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN,
619                         GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK,
620                         GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN,
621                         GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK
622                 };
623                 size_t i;
624                 for(i = 0; i < sizeof(tags)/sizeof(tags[0]); i++) {
625                         op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
626                         op->argument.vc_field_name.value = local_strdup((const char *)tags[i]);
627                 }
628         }
629         else if(0 == strcmp(opt, "add-padding")) {
630                 op = append_shorthand_operation(options, OP__ADD_PADDING);
631                 FLAC__ASSERT(0 != option_argument);
632                 if(!parse_add_padding(option_argument, &(op->argument.add_padding.length))) {
633                         flac_fprintf(stderr, "ERROR (--%s): illegal length \"%s\", length must be >= 0 and < 2^%u\n", opt, option_argument, FLAC__STREAM_METADATA_LENGTH_LEN);
634                         ok = false;
635                 }
636         }
637         else if(0 == strcmp(opt, "help")) {
638                 options->show_long_help = true;
639         }
640         else if(0 == strcmp(opt, "version")) {
641                 options->show_version = true;
642         }
643         else if(0 == strcmp(opt, "list")) {
644                 (void) append_major_operation(options, OP__LIST);
645         }
646         else if(0 == strcmp(opt, "append")) {
647                 (void) append_major_operation(options, OP__APPEND);
648         }
649         else if(0 == strcmp(opt, "remove")) {
650                 (void) append_major_operation(options, OP__REMOVE);
651         }
652         else if(0 == strcmp(opt, "remove-all")) {
653                 (void) append_major_operation(options, OP__REMOVE_ALL);
654         }
655         else if(0 == strcmp(opt, "merge-padding")) {
656                 (void) append_major_operation(options, OP__MERGE_PADDING);
657         }
658         else if(0 == strcmp(opt, "sort-padding")) {
659                 (void) append_major_operation(options, OP__SORT_PADDING);
660         }
661         else if(0 == strcmp(opt, "block-number")) {
662                 arg = append_argument(options, ARG__BLOCK_NUMBER);
663                 FLAC__ASSERT(0 != option_argument);
664                 if(!parse_block_number(option_argument, &(arg->value.block_number))) {
665                         flac_fprintf(stderr, "ERROR: malformed block number specification \"%s\"\n", option_argument);
666                         ok = false;
667                 }
668         }
669         else if(0 == strcmp(opt, "block-type")) {
670                 arg = append_argument(options, ARG__BLOCK_TYPE);
671                 FLAC__ASSERT(0 != option_argument);
672                 if(!parse_block_type(option_argument, &(arg->value.block_type))) {
673                         flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
674                         ok = false;
675                 }
676                 options->args.checks.has_block_type = true;
677         }
678         else if(0 == strcmp(opt, "except-block-type")) {
679                 arg = append_argument(options, ARG__EXCEPT_BLOCK_TYPE);
680                 FLAC__ASSERT(0 != option_argument);
681                 if(!parse_block_type(option_argument, &(arg->value.block_type))) {
682                         flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
683                         ok = false;
684                 }
685                 options->args.checks.has_except_block_type = true;
686         }
687         else if(0 == strcmp(opt, "data-format")) {
688                 arg = append_argument(options, ARG__DATA_FORMAT);
689                 FLAC__ASSERT(0 != option_argument);
690                 if(!parse_data_format(option_argument, &(arg->value.data_format))) {
691                         flac_fprintf(stderr, "ERROR (--%s): illegal data format \"%s\"\n", opt, option_argument);
692                         ok = false;
693                 }
694         }
695         else if(0 == strcmp(opt, "application-data-format")) {
696                 FLAC__ASSERT(0 != option_argument);
697                 if(!parse_application_data_format(option_argument, &(options->application_data_format_is_hexdump))) {
698                         flac_fprintf(stderr, "ERROR (--%s): illegal application data format \"%s\"\n", opt, option_argument);
699                         ok = false;
700                 }
701         }
702         else if(0 == strcmp(opt, "from-file")) {
703                 arg = append_argument(options, ARG__FROM_FILE);
704                 FLAC__ASSERT(0 != option_argument);
705                 arg->value.from_file.file_name = local_strdup(option_argument);
706         }
707         else {
708                 FLAC__ASSERT(0);
709         }
710
711         return ok;
712 }
713
714 void append_new_operation(CommandLineOptions *options, Operation operation)
715 {
716         if(options->ops.capacity == 0) {
717                 options->ops.capacity = 50;
718                 if(0 == (options->ops.operations = malloc(sizeof(Operation) * options->ops.capacity)))
719                         die("out of memory allocating space for option list");
720                 memset(options->ops.operations, 0, sizeof(Operation) * options->ops.capacity);
721         }
722         if(options->ops.capacity <= options->ops.num_operations) {
723                 unsigned original_capacity = options->ops.capacity;
724                 if(options->ops.capacity > UINT32_MAX / 2) /* overflow check */
725                         die("out of memory allocating space for option list");
726                 options->ops.capacity *= 2;
727                 if(0 == (options->ops.operations = safe_realloc_mul_2op_(options->ops.operations, sizeof(Operation), /*times*/options->ops.capacity)))
728                         die("out of memory allocating space for option list");
729                 memset(options->ops.operations + original_capacity, 0, sizeof(Operation) * (options->ops.capacity - original_capacity));
730         }
731
732         options->ops.operations[options->ops.num_operations++] = operation;
733 }
734
735 void append_new_argument(CommandLineOptions *options, Argument argument)
736 {
737         if(options->args.capacity == 0) {
738                 options->args.capacity = 50;
739                 if(0 == (options->args.arguments = malloc(sizeof(Argument) * options->args.capacity)))
740                         die("out of memory allocating space for option list");
741                 memset(options->args.arguments, 0, sizeof(Argument) * options->args.capacity);
742         }
743         if(options->args.capacity <= options->args.num_arguments) {
744                 unsigned original_capacity = options->args.capacity;
745                 if(options->args.capacity > UINT32_MAX / 2) /* overflow check */
746                         die("out of memory allocating space for option list");
747                 options->args.capacity *= 2;
748                 if(0 == (options->args.arguments = safe_realloc_mul_2op_(options->args.arguments, sizeof(Argument), /*times*/options->args.capacity)))
749                         die("out of memory allocating space for option list");
750                 memset(options->args.arguments + original_capacity, 0, sizeof(Argument) * (options->args.capacity - original_capacity));
751         }
752
753         options->args.arguments[options->args.num_arguments++] = argument;
754 }
755
756 Operation *append_major_operation(CommandLineOptions *options, OperationType type)
757 {
758         Operation op;
759         memset(&op, 0, sizeof(op));
760         op.type = type;
761         append_new_operation(options, op);
762         options->args.checks.num_major_ops++;
763         return options->ops.operations + (options->ops.num_operations - 1);
764 }
765
766 Operation *append_shorthand_operation(CommandLineOptions *options, OperationType type)
767 {
768         Operation op;
769         memset(&op, 0, sizeof(op));
770         op.type = type;
771         append_new_operation(options, op);
772         options->args.checks.num_shorthand_ops++;
773         return options->ops.operations + (options->ops.num_operations - 1);
774 }
775
776 Argument *find_argument(CommandLineOptions *options, ArgumentType type)
777 {
778         unsigned i;
779         for(i = 0; i < options->args.num_arguments; i++)
780                 if(options->args.arguments[i].type == type)
781                         return &options->args.arguments[i];
782         return 0;
783 }
784
785 Operation *find_shorthand_operation(CommandLineOptions *options, OperationType type)
786 {
787         unsigned i;
788         for(i = 0; i < options->ops.num_operations; i++)
789                 if(options->ops.operations[i].type == type)
790                         return &options->ops.operations[i];
791         return 0;
792 }
793
794 Argument *append_argument(CommandLineOptions *options, ArgumentType type)
795 {
796         Argument arg;
797         memset(&arg, 0, sizeof(arg));
798         arg.type = type;
799         append_new_argument(options, arg);
800         return options->args.arguments + (options->args.num_arguments - 1);
801 }
802
803 FLAC__bool parse_md5(const char *src, FLAC__byte dest[16])
804 {
805         unsigned i, d;
806         int c;
807         FLAC__ASSERT(0 != src);
808         if(strlen(src) != 32)
809                 return false;
810         /* strtoul() accepts negative numbers which we do not want, so we do it the hard way */
811         for(i = 0; i < 16; i++) {
812                 c = (int)(*src++);
813                 if(isdigit(c))
814                         d = (unsigned)(c - '0');
815                 else if(c >= 'a' && c <= 'f')
816                         d = (unsigned)(c - 'a') + 10u;
817                 else if(c >= 'A' && c <= 'F')
818                         d = (unsigned)(c - 'A') + 10u;
819                 else
820                         return false;
821                 d <<= 4;
822                 c = (int)(*src++);
823                 if(isdigit(c))
824                         d |= (unsigned)(c - '0');
825                 else if(c >= 'a' && c <= 'f')
826                         d |= (unsigned)(c - 'a') + 10u;
827                 else if(c >= 'A' && c <= 'F')
828                         d |= (unsigned)(c - 'A') + 10u;
829                 else
830                         return false;
831                 dest[i] = (FLAC__byte)d;
832         }
833         return true;
834 }
835
836 FLAC__bool parse_uint32(const char *src, FLAC__uint32 *dest)
837 {
838         FLAC__ASSERT(0 != src);
839         if(strlen(src) == 0 || strspn(src, "0123456789") != strlen(src))
840                 return false;
841         *dest = strtoul(src, 0, 10);
842         return true;
843 }
844
845 FLAC__bool parse_uint64(const char *src, FLAC__uint64 *dest)
846 {
847         FLAC__ASSERT(0 != src);
848         if(strlen(src) == 0 || strspn(src, "0123456789") != strlen(src))
849                 return false;
850         *dest = strtoull(src, 0, 10);
851         return true;
852 }
853
854 FLAC__bool parse_string(const char *src, char **dest)
855 {
856         if(0 == src || strlen(src) == 0)
857                 return false;
858         *dest = strdup(src);
859         return true;
860 }
861
862 FLAC__bool parse_vorbis_comment_field_name(const char *field_ref, char **name, const char **violation)
863 {
864         static const char * const violations[] = {
865                 "field name contains invalid character"
866         };
867
868         char *q, *s;
869
870         s = local_strdup(field_ref);
871
872         for(q = s; *q; q++) {
873                 if(*q < 0x20 || *q > 0x7d || *q == 0x3d) {
874                         free(s);
875                         *violation = violations[0];
876                         return false;
877                 }
878         }
879
880         *name = s;
881
882         return true;
883 }
884
885 FLAC__bool parse_add_seekpoint(const char *in, char **out, const char **violation)
886 {
887         static const char *garbled_ = "garbled specification";
888         const unsigned n = strlen(in);
889
890         FLAC__ASSERT(0 != in);
891         FLAC__ASSERT(0 != out);
892
893         if(n == 0) {
894                 *violation = "specification is empty";
895                 return false;
896         }
897
898         if(n > strspn(in, "0123456789.Xsx")) {
899                 *violation = "specification contains invalid character";
900                 return false;
901         }
902
903         if(in[n-1] == 'X') {
904                 if(n > 1) {
905                         *violation = garbled_;
906                         return false;
907                 }
908         }
909         else if(in[n-1] == 's') {
910                 if(n-1 > strspn(in, "0123456789.")) {
911                         *violation = garbled_;
912                         return false;
913                 }
914         }
915         else if(in[n-1] == 'x') {
916                 if(n-1 > strspn(in, "0123456789")) {
917                         *violation = garbled_;
918                         return false;
919                 }
920         }
921         else {
922                 if(n > strspn(in, "0123456789")) {
923                         *violation = garbled_;
924                         return false;
925                 }
926         }
927
928         *out = local_strdup(in);
929         return true;
930 }
931
932 FLAC__bool parse_add_padding(const char *in, unsigned *out)
933 {
934         FLAC__ASSERT(0 != in);
935         FLAC__ASSERT(0 != out);
936         *out = (unsigned)strtoul(in, 0, 10);
937         return *out < (1u << FLAC__STREAM_METADATA_LENGTH_LEN);
938 }
939
940 FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out)
941 {
942         char *p, *q, *s, *end;
943         long i;
944         unsigned entry;
945
946         if(*in == '\0')
947                 return false;
948
949         s = local_strdup(in);
950
951         /* first count the entries */
952         for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
953                 ;
954
955         /* make space */
956         FLAC__ASSERT(out->num_entries > 0);
957         if(0 == (out->entries = safe_malloc_mul_2op_(sizeof(unsigned), /*times*/out->num_entries)))
958                 die("out of memory allocating space for option list");
959
960         /* load 'em up */
961         entry = 0;
962         q = s;
963         while(q) {
964                 FLAC__ASSERT(entry < out->num_entries);
965                 if(0 != (p = strchr(q, ',')))
966                         *p++ = '\0';
967                 if(!isdigit((int)(*q)) || (i = strtol(q, &end, 10)) < 0 || *end) {
968                         free(s);
969                         return false;
970                 }
971                 out->entries[entry++] = (unsigned)i;
972                 q = p;
973         }
974         FLAC__ASSERT(entry == out->num_entries);
975
976         free(s);
977         return true;
978 }
979
980 FLAC__bool parse_block_type(const char *in, Argument_BlockType *out)
981 {
982         char *p, *q, *r, *s;
983         unsigned entry;
984
985         if(*in == '\0')
986                 return false;
987
988         s = local_strdup(in);
989
990         /* first count the entries */
991         for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
992                 ;
993
994         /* make space */
995         FLAC__ASSERT(out->num_entries > 0);
996         if(0 == (out->entries = safe_malloc_mul_2op_(sizeof(Argument_BlockTypeEntry), /*times*/out->num_entries)))
997                 die("out of memory allocating space for option list");
998
999         /* load 'em up */
1000         entry = 0;
1001         q = s;
1002         while(q) {
1003                 FLAC__ASSERT(entry < out->num_entries);
1004                 if(0 != (p = strchr(q, ',')))
1005                         *p++ = 0;
1006                 r = strchr(q, ':');
1007                 if(r)
1008                         *r++ = '\0';
1009                 if(0 != r && 0 != strcmp(q, "APPLICATION")) {
1010                         free(s);
1011                         return false;
1012                 }
1013                 if(0 == strcmp(q, "STREAMINFO")) {
1014                         out->entries[entry++].type = FLAC__METADATA_TYPE_STREAMINFO;
1015                 }
1016                 else if(0 == strcmp(q, "PADDING")) {
1017                         out->entries[entry++].type = FLAC__METADATA_TYPE_PADDING;
1018                 }
1019                 else if(0 == strcmp(q, "APPLICATION")) {
1020                         out->entries[entry].type = FLAC__METADATA_TYPE_APPLICATION;
1021                         out->entries[entry].filter_application_by_id = (0 != r);
1022                         if(0 != r) {
1023                                 if(strlen(r) == sizeof (out->entries[entry].application_id)) {
1024                                         memcpy(out->entries[entry].application_id, r, sizeof (out->entries[entry].application_id));
1025                                 }
1026                                 else if(strlen(r) == 10 && FLAC__STRNCASECMP(r, "0x", 2) == 0 && strspn(r+2, "0123456789ABCDEFabcdef") == 8) {
1027                                         FLAC__uint32 x = strtoul(r+2, 0, 16);
1028                                         out->entries[entry].application_id[3] = (FLAC__byte)(x & 0xff);
1029                                         out->entries[entry].application_id[2] = (FLAC__byte)((x>>=8) & 0xff);
1030                                         out->entries[entry].application_id[1] = (FLAC__byte)((x>>=8) & 0xff);
1031                                         out->entries[entry].application_id[0] = (FLAC__byte)((x>>=8) & 0xff);
1032                                 }
1033                                 else {
1034                                         free(s);
1035                                         return false;
1036                                 }
1037                         }
1038                         entry++;
1039                 }
1040                 else if(0 == strcmp(q, "SEEKTABLE")) {
1041                         out->entries[entry++].type = FLAC__METADATA_TYPE_SEEKTABLE;
1042                 }
1043                 else if(0 == strcmp(q, "VORBIS_COMMENT")) {
1044                         out->entries[entry++].type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
1045                 }
1046                 else if(0 == strcmp(q, "CUESHEET")) {
1047                         out->entries[entry++].type = FLAC__METADATA_TYPE_CUESHEET;
1048                 }
1049                 else if(0 == strcmp(q, "PICTURE")) {
1050                         out->entries[entry++].type = FLAC__METADATA_TYPE_PICTURE;
1051                 }
1052                 else {
1053                         free(s);
1054                         return false;
1055                 }
1056                 q = p;
1057         }
1058         FLAC__ASSERT(entry == out->num_entries);
1059
1060         free(s);
1061         return true;
1062 }
1063
1064 FLAC__bool parse_data_format(const char *in, Argument_DataFormat *out)
1065 {
1066         if(0 == strcmp(in, "binary"))
1067                 out->is_binary = true;
1068         else if(0 == strcmp(in, "text"))
1069                 out->is_binary = false;
1070         else
1071                 return false;
1072         return true;
1073 }
1074
1075 FLAC__bool parse_application_data_format(const char *in, FLAC__bool *out)
1076 {
1077         if(0 == strcmp(in, "hexdump"))
1078                 *out = true;
1079         else if(0 == strcmp(in, "text"))
1080                 *out = false;
1081         else
1082                 return false;
1083         return true;
1084 }
1085
1086 void undocumented_warning(const char *opt)
1087 {
1088         flac_fprintf(stderr, "WARNING: undocumented option --%s should be used with caution,\n         only for repairing a damaged STREAMINFO block\n", opt);
1089 }