src/fatlabel.c - master - githubmirror/dosfstools

src/fatlabel.c
298 строк7 KB
Michael Vrable
fatlabel: Fix a compiler warning about a maybe-unitialized variable
03 мар 2023, 22:35
03 мар 2023, 22:35dc27b5f
/* fatlabel.c - User interface

   Copyright (C) 1993 Werner Almesberger <werner.almesberger@lrc.di.epfl.ch>
   Copyright (C) 1998 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
   Copyright (C) 2007 Red Hat, Inc.
   Copyright (C) 2008-2014 Daniel Baumann <mail@daniel-baumann.ch>
   Copyright (C) 2015-2017 Andreas Bombe <aeb@debian.org>
   Copyright (C) 2017-2018 Pali Rohár <pali.rohar@gmail.com>

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program. If not, see <http://www.gnu.org/licenses/>.

   The complete text of the GNU General Public License
   can be found in /usr/share/common-licenses/GPL-3 file.
*/

#include "version.h"

#include <stdbool.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <unistd.h>
#include <getopt.h>
#include <ctype.h>

#include "common.h"
#include "fsck.fat.h"
#include "io.h"
#include "boot.h"
#include "fat.h"
#include "file.h"
#include "check.h"
#include "charconv.h"

int rw = 0, list = 0, test = 0, verbose = 0, no_spaces_in_sfns = 0;
long fat_table = 0;
unsigned n_files = 0;
void *mem_queue = NULL;


static void handle_label(bool change, bool reset, const char *device, char *newlabel)
{
    DOS_FS fs = { 0 };
    off_t offset;
    DIR_ENT de;

    char label[12] = { 0 };
    size_t len;
    int ret;
    int i;

    if (change) {
	len = mbstowcs(NULL, newlabel, 0);
	if (len != (size_t)-1 && len > 11) {
	    fprintf(stderr,
		    "fatlabel: labels can be no longer than 11 characters\n");
	    exit(1);
	}

	if (!local_string_to_dos_string(label, newlabel, 12)) {
	    fprintf(stderr,
		    "fatlabel: error when processing label\n");
	    exit(1);
	}

	for (i = strlen(label); i < 11; ++i)
	    label[i] = ' ';
	label[11] = 0;

	ret = validate_volume_label(label);
	if (ret & 0x1) {
	    fprintf(stderr,
		    "fatlabel: warning - lowercase labels might not work properly on some systems\n");
	}
	if (ret & 0x2) {
	    fprintf(stderr,
		    "fatlabel: labels with characters below 0x20 are not allowed\n");
	    exit(1);
	}
	if (ret & 0x4) {
	    fprintf(stderr,
		    "fatlabel: labels with characters *?.,;:/\\|+=<>[]\" are not allowed\n");
	    exit(1);
	}
	if (ret & 0x08) {
	    fprintf(stderr,
		    "fatlabel: labels can't be empty or white space only\n");
	    exit(1);
	}
	if (ret & 0x10) {
	    fprintf(stderr,
		    "fatlabel: labels can't start with a space character\n");
	    exit(1);
	}
    }

    fs_open(device, rw);
    read_boot(&fs);

    if (!change && !reset) {
	if (fs.fat_bits == 32)
	    read_fat(&fs, 0);

	offset = find_volume_de(&fs, &de);
	if (offset != 0) {
	    if (de.name[0] == 0x05)
		de.name[0] = 0xe5;
	    printf("%s\n", pretty_label((char *)de.name, '_'));
	}

	if (fs.fat_bits == 32)
	    release_fat(&fs);

	exit(0);
    }

    if (fs.fat_bits == 32)
	read_fat(&fs, 1);

    if (!reset)
	write_label(&fs, label);
    else
	remove_label(&fs);

    if (fs.fat_bits == 32)
	release_fat(&fs);
}


static void handle_volid(bool change, bool reset, const char *device, const char *newserial)
{
    DOS_FS fs = { 0 };
    char *tmp;
    long long conversion;
    uint32_t serial = 0;

    if (change) {
	errno = 0;
	conversion = strtoll(newserial, &tmp, 16);

	if (!*newserial || isspace((unsigned char)*newserial) || *tmp || conversion < 0) {
	    fprintf(stderr, "fatlabel: volume ID must be a hexadecimal number\n");
	    exit(1);
	}
	if (conversion > UINT32_MAX) {
	    fprintf(stderr, "fatlabel: given volume ID does not fit in 32 bit\n");
	    exit(1);
	}
	if (errno) {
	    fprintf(stderr, "fatlabel: parsing volume ID failed (%s)\n", strerror(errno));
	    exit(1);
	}

	serial = conversion;
    }

    if (reset)
	serial = generate_volume_id();

    fs_open(device, rw);
    read_boot(&fs);
    if (!change && !reset) {
	printf("%08x\n", fs.serial);
	exit(0);
    }

    write_serial(&fs, serial);
}


static void usage(char *name, int error, int usage_only)
{
    FILE *f = error ? stderr : stdout;
    int status = error ? 1 : 0;

    fprintf(f, "fatlabel " VERSION " (" VERSION_DATE ")\n");
    fprintf(f, "Usage: %s [OPTIONS] DEVICE [NEW]\n", name);
    if (usage_only)
	exit(status);

    fprintf(f, "Change the FAT filesystem label or serial on DEVICE to NEW or display the\n");
    fprintf(f, "existing label or serial if NEW is not given.\n");
    fprintf(f, "\n");
    fprintf(f, "Options:\n");
    fprintf(f, "  -i, --volume-id     Work on serial number instead of label\n");
    fprintf(f, "  -r, --reset         Remove label or generate new serial number\n");
    fprintf(f, "  -c N, --codepage=N  use DOS codepage N to encode/decode label (default: %d)\n", DEFAULT_DOS_CODEPAGE);
    fprintf(f, "  -V, --version       Show version number and terminate\n");
    fprintf(f, "  -h, --help          Print this message and terminate\n");
    exit(status);
}


int main(int argc, char *argv[])
{
    const struct option long_options[] = {
	{"volume-id", no_argument, NULL, 'i'},
	{"reset",     no_argument, NULL, 'r'},
	{"codepage",  required_argument, NULL, 'c'},
	{"version",   no_argument, NULL, 'V'},
	{"help",      no_argument, NULL, 'h'},
	{0,}
    };
    bool change = false;
    bool reset = false;
    bool volid_mode = false;
    char *device = NULL;
    char *new = NULL;
    char *tmp;
    long codepage = -1;
    int c;

    check_atari();

    while ((c = getopt_long(argc, argv, "irc:Vh", long_options, NULL)) != -1) {
	switch (c) {
	    case 'i':
		volid_mode = 1;
		break;

	    case 'r':
		reset = true;
		break;

	    case 'c':
		errno = 0;
		codepage = strtol(optarg, &tmp, 10);
		if (!*optarg || isspace((unsigned char)*optarg) || *tmp || errno || codepage < 0 || codepage > INT_MAX) {
		    fprintf(stderr, "Invalid codepage : %s\n", optarg);
		    usage(argv[0], 1, 0);
		}
		break;

	    case 'V':
		printf("fatlabel " VERSION " (" VERSION_DATE ")\n");
		exit(0);
		break;

	    case 'h':
		usage(argv[0], 0, 0);
		break;

	    case '?':
		usage(argv[0], 1, 0);
		exit(1);

	    default:
		fprintf(stderr,
			"Internal error: getopt_long() returned unexpected value %d\n", c);
		exit(2);
	}
    }

    if (!set_dos_codepage(codepage))
        exit(1);

    if (optind == argc - 2) {
	change = true;
    } else if (optind == argc - 1) {
	change = false;
    } else {
	usage(argv[0], 1, 1);
    }

    if (change || reset)
	rw = 1;

    if (change && reset) {
	fprintf(stderr, "fatlabel: giving new value with --reset not allowed\n");
	exit(1);
    }

    device = argv[optind++];
    if (change)
	new = argv[optind];

    if (!volid_mode)
	handle_label(change, reset, device, new);
    else
	handle_volid(change, reset, device, new);

    fs_close(rw);
    return 0;
}