Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sbin/fsck_udf/main.c

4478 lines
118 KiB
C
Raw Permalink Blame History

/* $NetBSD: main.c,v 1.14 2023/08/03 08:06:11 mrg Exp $ */
/*
* Copyright (c) 2022 Reinoud Zandijk
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Note to reader:
*
* fsck_udf uses the common udf_core.c file with newfs and makefs. It does use
* some of the layout structure values but not all.
*/
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: main.c,v 1.14 2023/08/03 08:06:11 mrg Exp $");
#endif /* not lint */
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <dirent.h>
#include <inttypes.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <util.h>
#include <time.h>
#include <tzfile.h>
#include <math.h>
#include <assert.h>
#include <err.h>
#if !HAVE_NBTOOL_CONFIG_H
#define _EXPOSE_MMC
#include <sys/cdio.h>
#else
#include "udf/cdio_mmc_structs.h"
#endif
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/disklabel.h>
#include <sys/dkio.h>
#include <sys/param.h>
#include <sys/queue.h>
#include <fs/udf/ecma167-udf.h>
#include <fs/udf/udf_mount.h>
#include "fsutil.h"
#include "exitvalues.h"
#include "udf_core.h"
/* Identifying myself */
#define IMPL_NAME "*NetBSD fsck_udf 10.0"
#define APP_VERSION_MAIN 0
#define APP_VERSION_SUB 5
/* allocation walker actions */
#define AD_LOAD_FILE (1<<0)
#define AD_SAVE_FILE (1<<1)
#define AD_CHECK_FIDS (1<<2)
#define AD_ADJUST_FIDS (1<<3)
#define AD_GATHER_STATS (1<<4)
#define AD_CHECK_USED (1<<5)
#define AD_MARK_AS_USED (1<<6)
#define AD_FIND_OVERLAP_PAIR (1<<7)
struct udf_fsck_file_stats {
uint64_t inf_len;
uint64_t obj_size;
uint64_t logblks_rec;
};
struct udf_fsck_fid_context {
uint64_t fid_offset;
uint64_t data_left;
};
/* basic node administration for passes */
#define FSCK_NODE_FLAG_HARDLINK (1<< 0) /* hardlink, for accounting */
#define FSCK_NODE_FLAG_DIRECTORY (1<< 1) /* is a normal directory */
#define FSCK_NODE_FLAG_HAS_STREAM_DIR (1<< 2) /* has a stream directory */
#define FSCK_NODE_FLAG_STREAM_ENTRY (1<< 3) /* is a stream file */
#define FSCK_NODE_FLAG_STREAM_DIR (1<< 4) /* is a stream directory */
#define FSCK_NODE_FLAG_OK(f) (((f) >> 5) == 0)
#define FSCK_NODE_FLAG_KEEP (1<< 5) /* don't discard */
#define FSCK_NODE_FLAG_DIRTY (1<< 6) /* descriptor needs writeout */
#define FSCK_NODE_FLAG_REPAIRDIR (1<< 7) /* repair bad FID entries */
#define FSCK_NODE_FLAG_NEW_UNIQUE_ID (1<< 8) /* repair bad FID entries */
#define FSCK_NODE_FLAG_COPY_PARENT_ID (1<< 9) /* repair bad FID entries */
#define FSCK_NODE_FLAG_WIPE_STREAM_DIR (1<<10) /* wipe stream directory */
#define FSCK_NODE_FLAG_NOTFOUND (1<<11) /* FID pointing to garbage */
#define FSCK_NODE_FLAG_PAR_NOT_FOUND (1<<12) /* parent node not found! */
#define FSCK_NODE_FLAG_OVERLAP (1<<13) /* node has overlaps */
#define FSCK_NODE_FLAG_STREAM (FSCK_NODE_FLAG_STREAM_ENTRY | FSCK_NODE_FLAG_STREAM_DIR)
#define HASH_HASHBITS 5
#define HASH_HASHSIZE (1 << HASH_HASHBITS)
#define HASH_HASHMASK (HASH_HASHSIZE - 1)
/* fsck node for accounting checks */
struct udf_fsck_node {
struct udf_fsck_node *parent;
char *fname;
struct long_ad loc;
struct long_ad streamdir_loc;
int fsck_flags;
int link_count;
int found_link_count;
uint64_t unique_id;
struct udf_fsck_file_stats declared;
struct udf_fsck_file_stats found;
uint8_t *directory; /* directory contents */
LIST_ENTRY(udf_fsck_node) next_hash;
TAILQ_ENTRY(udf_fsck_node) next;
};
TAILQ_HEAD(udf_fsck_node_list, udf_fsck_node) fs_nodes;
LIST_HEAD(udf_fsck_node_hash_list, udf_fsck_node) fs_nodes_hash[HASH_HASHSIZE];
/* fsck used space bitmap conflict list */
#define FSCK_OVERLAP_MAIN_NODE (1<<0)
#define FSCK_OVERLAP_EXTALLOC (1<<1)
#define FSCK_OVERLAP_EXTENT (1<<2)
struct udf_fsck_overlap {
struct udf_fsck_node *node;
struct udf_fsck_node *node2;
struct long_ad loc;
struct long_ad loc2;
int flags;
int flags2;
TAILQ_ENTRY(udf_fsck_overlap) next;
};
TAILQ_HEAD(udf_fsck_overlap_list, udf_fsck_overlap) fsck_overlaps;
/* backup of old read in free space bitmaps */
struct space_bitmap_desc *recorded_part_unalloc_bits[UDF_PARTITIONS];
uint32_t recorded_part_free[UDF_PARTITIONS];
/* shadow VAT build */
uint8_t *shadow_vat_contents;
/* options */
int alwaysno = 0; /* assume "no" for all questions */
int alwaysyes = 0; /* assume "yes" for all questions */
int search_older_vat = 0; /* search for older VATs */
int force = 0; /* do check even if its marked clean */
int preen = 0; /* set when preening, doing automatic small repairs */
int rdonly = 0; /* open device/image read-only */
int rdonly_flag = 0; /* as passed on command line */
int heuristics = 0; /* use heuristics to fix esoteric corruptions */
int target_session = 0; /* offset to last session to check */
/* actions to undertake */
int undo_opening_session = 0; /* trying to undo opening of last crippled session */
int open_integrity = 0; /* should be open the integrity ie close later */
int vat_writeout = 0; /* write out the VAT anyway */
/* SIGINFO */
static sig_atomic_t print_info = 0; /* request for information on progress */
/* prototypes */
static void usage(void) __dead;
static int checkfilesys(char *given_dev);
static int ask(int def, const char *fmt, ...);
static int ask_noauto(int def, const char *fmt, ...);
static void udf_recursive_keep(struct udf_fsck_node *node);
static char *udf_node_path(struct udf_fsck_node *node);
static void udf_shadow_VAT_in_use(struct long_ad *loc);
static int udf_quick_check_fids(struct udf_fsck_node *node, union dscrptr *dscr);
/* --------------------------------------------------------------------- */
/* from bin/ls */
static void
printtime(time_t ftime)
{
struct timespec clock;
const char *longstring;
time_t now;
int i;
clock_gettime(CLOCK_REALTIME, &clock);
now = clock.tv_sec;
if ((longstring = ctime(&ftime)) == NULL) {
/* 012345678901234567890123 */
longstring = "????????????????????????";
}
for (i = 4; i < 11; ++i)
(void)putchar(longstring[i]);
#define SIXMONTHS ((DAYSPERNYEAR / 2) * SECSPERDAY)
if (ftime + SIXMONTHS > now && ftime - SIXMONTHS < now)
for (i = 11; i < 16; ++i)
(void)putchar(longstring[i]);
else {
(void)putchar(' ');
for (i = 20; i < 24; ++i)
(void)putchar(longstring[i]);
}
(void)putchar(' ');
}
static void
udf_print_timestamp(const char *prefix, struct timestamp *timestamp, const char *suffix)
{
struct timespec timespec;
udf_timestamp_to_timespec(timestamp, &timespec);
printf("%s", prefix);
printtime(timespec.tv_sec);
printf("%s", suffix);
}
static int
udf_compare_mtimes(struct timestamp *t1, struct timestamp *t2)
{
struct timespec t1_tsp, t2_tsp;
udf_timestamp_to_timespec(t1, &t1_tsp);
udf_timestamp_to_timespec(t2, &t2_tsp);
if (t1_tsp.tv_sec < t2_tsp.tv_sec)
return -1;
if (t1_tsp.tv_sec > t2_tsp.tv_sec)
return 1;
if (t1_tsp.tv_nsec < t2_tsp.tv_nsec)
return -1;
if (t1_tsp.tv_nsec > t2_tsp.tv_nsec)
return 1;
return 0;
}
/* --------------------------------------------------------------------- */
static int
udf_calc_node_hash(struct long_ad *icb)
{
uint32_t lb_num = udf_rw32(icb->loc.lb_num);
uint16_t vpart = udf_rw16(icb->loc.part_num);
return ((uint64_t) (vpart + lb_num * 257)) & HASH_HASHMASK;
}
static struct udf_fsck_node *
udf_node_lookup(struct long_ad *icb)
{
struct udf_fsck_node *pos;
int entry = udf_calc_node_hash(icb);
pos = LIST_FIRST(&fs_nodes_hash[entry]);
while (pos) {
if (pos->loc.loc.part_num == icb->loc.part_num)
if (pos->loc.loc.lb_num == icb->loc.lb_num)
return pos;
pos = LIST_NEXT(pos, next_hash);
}
return NULL;
}
/* --------------------------------------------------------------------- */
/* Note: only for VAT media since we don't allocate in bitmap */
static void
udf_wipe_and_reallocate(union dscrptr *dscrptr, int vpart_num, uint32_t *l_adp)
{
struct file_entry *fe = &dscrptr->fe;
struct extfile_entry *efe = &dscrptr->efe;
struct desc_tag *tag = &dscrptr->tag;
struct icb_tag *icb;
struct long_ad allocated;
struct long_ad *long_adp = NULL;
struct short_ad *short_adp = NULL;
uint64_t inf_len;
uint32_t l_ea, l_ad;
uint8_t *bpos;
int bpos_start, ad_type, id;
assert(context.format_flags & FORMAT_VAT);
id = udf_rw16(tag->id);
assert(id == TAGID_FENTRY || id == TAGID_EXTFENTRY);
if (id == TAGID_FENTRY) {
icb = &fe->icbtag;
inf_len = udf_rw64(fe->inf_len);
l_ea = udf_rw32(fe->l_ea);
bpos = (uint8_t *) fe->data + l_ea;
bpos_start = offsetof(struct file_entry, data) + l_ea;
} else {
icb = &efe->icbtag;
inf_len = udf_rw64(efe->inf_len);
l_ea = udf_rw32(efe->l_ea);
bpos = (uint8_t *) efe->data + l_ea;
bpos_start = offsetof(struct extfile_entry, data) + l_ea;
}
/* inf_len should be correct for one slot */
assert(inf_len < UDF_EXT_MAXLEN);
ad_type = udf_rw16(icb->flags) & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
/* no action needed */
return;
}
assert(vpart_num == context.data_part);
udf_data_alloc(udf_bytes_to_sectors(inf_len), &allocated);
memset(bpos, 0, context.sector_size - bpos_start);
/* create one short_ad or one long_ad */
if (ad_type == UDF_ICB_SHORT_ALLOC) {
short_adp = (struct short_ad *) bpos;
short_adp->len = udf_rw32(inf_len);
short_adp->lb_num = allocated.loc.lb_num;
l_ad = sizeof(struct short_ad);
} else {
long_adp = (struct long_ad *) bpos;
memcpy(long_adp, &allocated, sizeof(struct long_ad));
long_adp->len = udf_rw32(inf_len);
l_ad = sizeof(struct long_ad);
}
if (id == TAGID_FENTRY)
fe->l_ad = udf_rw32(l_ad);
else
efe->l_ad = udf_rw32(l_ad);
;
*l_adp = l_ad;
}
static void
udf_copy_fid_verbatim(struct fileid_desc *sfid, struct fileid_desc *dfid,
uint64_t dfpos, uint64_t drest)
{
uint64_t endfid;
uint32_t minlen, lb_rest, fidsize;
if (udf_rw16(sfid->l_iu) == 0) {
memcpy(dfid, sfid, udf_fidsize(sfid));
return;
}
/* see if we can reduce its size */
minlen = udf_fidsize(sfid) - udf_rw16(sfid->l_iu);
/*
* OK, tricky part: we need to pad so the next descriptor header won't
* cross the sector boundary
*/
endfid = dfpos + minlen;
lb_rest = context.sector_size - (endfid % context.sector_size);
memcpy(dfid, sfid, UDF_FID_SIZE);
if (lb_rest < sizeof(struct desc_tag)) {
/* add at least 32 */
dfid->l_iu = udf_rw16(32);
udf_set_regid((struct regid *) dfid->data, context.impl_name);
udf_add_impl_regid((struct regid *) dfid->data);
}
memcpy( dfid->data + udf_rw16(dfid->l_iu),
sfid->data + udf_rw16(sfid->l_iu),
minlen - UDF_FID_SIZE);
fidsize = udf_fidsize(dfid);
dfid->tag.desc_crc_len = udf_rw16(fidsize - UDF_DESC_TAG_LENGTH);
}
static int
udf_rebuild_fid_stream(struct udf_fsck_node *node, int64_t *rest_lenp)
{
struct fileid_desc *sfid, *dfid;
uint64_t inf_len;
uint64_t sfpos, dfpos;
int64_t srest, drest;
// uint32_t sfid_len, dfid_len;
uint8_t *directory, *rebuild_dir;
// int namelen;
int error, streaming, was_streaming, warned, error_in_stream;
directory = node->directory;
inf_len = node->found.inf_len;
rebuild_dir = calloc(1, inf_len);
assert(rebuild_dir);
sfpos = 0;
srest = inf_len;
dfpos = 0;
drest = inf_len;
error_in_stream = 0;
streaming = 1;
was_streaming = 1;
warned = 0;
while (srest > 0) {
if (was_streaming & !streaming) {
if (!warned) {
pwarn("%s : BROKEN directory\n",
udf_node_path(node));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
warned = 1;
pwarn("%s : <directory resync>\n",
udf_node_path(node));
}
was_streaming = streaming;
assert(drest >= UDF_FID_SIZE);
sfid = (struct fileid_desc *) (directory + sfpos);
dfid = (struct fileid_desc *) (rebuild_dir + dfpos);
/* check if we can read/salvage the next source fid */
if (udf_rw16(sfid->tag.id) != TAGID_FID) {
streaming = 0;
sfpos += 4;
srest -= 4;
error_in_stream = 1;
continue;
}
error = udf_check_tag(sfid);
if (error) {
/* unlikely to be recoverable */
streaming = 0;
sfpos += 4;
srest -= 4;
error_in_stream = 1;
continue;
}
error = udf_check_tag_payload(
(union dscrptr *) sfid,
context.sector_size);
if (!error) {
streaming = 1;
/* all OK, just copy verbatim, shrinking if possible */
udf_copy_fid_verbatim(sfid, dfid, dfpos, drest);
sfpos += udf_fidsize(sfid);
srest -= udf_fidsize(sfid);
dfpos += udf_fidsize(dfid);
drest -= udf_fidsize(dfid);
assert(udf_fidsize(sfid) == udf_fidsize(dfid));
continue;
}
/*
* The hard part, we need to try to recover of what is
* deductible of the bad source fid. The tag itself is OK, but
* that doesn't say much; its contents can still be off.
*/
/* TODO NOT IMPLEMENTED YET, skip this entry the blunt way */
streaming = 0;
sfpos += 4;
srest -= 4;
error_in_stream = 1;
}
/* if we could shrink/fix the node, mark it for repair */
if (error_in_stream) {
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
if (sfpos != dfpos)
printf("%s: could save %" PRIi64 " bytes in directory\n", udf_node_path(node), sfpos - dfpos);
memset(directory, 0, inf_len);
memcpy(directory, rebuild_dir, dfpos);
free(rebuild_dir);
*rest_lenp = dfpos;
return error_in_stream;
}
static int
udf_quick_check_fids_piece(uint8_t *piece, uint32_t piece_len,
struct udf_fsck_fid_context *fid_context,
uint32_t lb_num)
{
int error;
struct fileid_desc *fid;
uint32_t location;
uint32_t offset, fidsize;
offset = fid_context->fid_offset % context.sector_size;
while (fid_context->data_left && (offset < piece_len)) {
fid = (struct fileid_desc *) (piece + offset);
if (udf_rw16(fid->tag.id) == TAGID_FID) {
error = udf_check_tag_payload(
(union dscrptr *) fid,
context.sector_size);
if (error)
return error;
} else {
return EINVAL;
}
assert(udf_rw16(fid->tag.id) == TAGID_FID);
location = lb_num + offset / context.sector_size;
if (udf_rw32(fid->tag.tag_loc) != location)
return EINVAL;
if (context.dscrver == 2) {
/* compression IDs should be preserved in UDF < 2.00 */
if (*(fid->data + udf_rw16(fid->l_iu)) > 16)
return EINVAL;
}
fidsize = udf_fidsize(fid);
offset += fidsize;
fid_context->fid_offset += fidsize;
fid_context->data_left -= fidsize;
}
return 0;
}
static void
udf_fids_fixup(uint8_t *piece, uint32_t piece_len,
struct udf_fsck_fid_context *fid_context,
uint32_t lb_num)
{
struct fileid_desc *fid;
uint32_t location;
uint32_t offset, fidsize;
offset = fid_context->fid_offset % context.sector_size;
while (fid_context->data_left && (offset < piece_len)) {
fid = (struct fileid_desc *) (piece + offset);
assert(udf_rw16(fid->tag.id) == TAGID_FID);
location = lb_num + offset / context.sector_size;
fid->tag.tag_loc = udf_rw32(location);
udf_validate_tag_and_crc_sums((union dscrptr *) fid);
fidsize = udf_fidsize(fid);
offset += fidsize;
fid_context->fid_offset += fidsize;
fid_context->data_left -= fidsize;
}
}
/* NOTE returns non 0 for overlap, not an error code */
static int
udf_check_if_allocated(struct udf_fsck_node *node, int flags,
uint32_t start_lb, int partnr, uint32_t piece_len)
{
union dscrptr *dscr;
struct udf_fsck_overlap *new_overlap;
uint8_t *bpos;
uint32_t cnt, bit;
uint32_t blocks = udf_bytes_to_sectors(piece_len);
int overlap = 0;
/* account for space used on underlying partition */
#ifdef DEBUG
printf("check allocated : node %p, flags %d, partnr %d, start_lb %d for %d blocks\n",
node, flags, partnr, start_lb, blocks);
#endif
switch (context.vtop_tp[partnr]) {
case UDF_VTOP_TYPE_VIRT:
/* nothing */
break;
case UDF_VTOP_TYPE_PHYS:
case UDF_VTOP_TYPE_SPAREABLE:
case UDF_VTOP_TYPE_META:
if (context.part_unalloc_bits[context.vtop[partnr]] == NULL)
break;
#ifdef DEBUG
printf("checking allocation of %d+%d for being used\n", start_lb, blocks);
#endif
dscr = (union dscrptr *) (context.part_unalloc_bits[partnr]);
for (cnt = start_lb; cnt < start_lb + blocks; cnt++) {
bpos = &dscr->sbd.data[cnt / 8];
bit = cnt % 8;
/* only account for bits marked free */
if ((*bpos & (1 << bit)) == 0)
overlap++;
}
if (overlap == 0)
break;
/* overlap */
// pwarn("%s allocation OVERLAP found, type %d\n",
// udf_node_path(node), flags);
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_OVERLAP;
new_overlap = calloc(1, sizeof(struct udf_fsck_overlap));
assert(new_overlap);
new_overlap->node = node;
new_overlap->node2 = NULL;
new_overlap->flags = flags;
new_overlap->flags2 = 0;
new_overlap->loc.len = udf_rw32(piece_len);
new_overlap->loc.loc.lb_num = udf_rw32(start_lb);
new_overlap->loc.loc.part_num = udf_rw16(partnr);
TAILQ_INSERT_TAIL(&fsck_overlaps, new_overlap, next);
return overlap;
break;
default:
errx(1, "internal error: bad mapping type %d in %s",
context.vtop_tp[partnr], __func__);
}
/* no overlap */
return 0;
}
/* NOTE returns non 0 for overlap, not an error code */
static void
udf_check_overlap_pair(struct udf_fsck_node *node, int flags,
uint32_t start_lb, int partnr, uint32_t piece_len)
{
struct udf_fsck_overlap *overlap;
uint32_t ostart_lb, opiece_len, oblocks;
uint32_t blocks = udf_bytes_to_sectors(piece_len);
int opartnr;
/* account for space used on underlying partition */
#ifdef DEBUG
printf("check overlap pair : node %p, flags %d, partnr %d, start_lb %d for %d blocks\n",
node, flags, partnr, start_lb, blocks);
#endif
switch (context.vtop_tp[partnr]) {
case UDF_VTOP_TYPE_VIRT:
/* nothing */
break;
case UDF_VTOP_TYPE_PHYS:
case UDF_VTOP_TYPE_SPAREABLE:
case UDF_VTOP_TYPE_META:
if (context.part_unalloc_bits[context.vtop[partnr]] == NULL)
break;
#ifdef DEBUG
printf("checking overlap of %d+%d for being used\n", start_lb, blocks);
#endif
/* check all current overlaps with the piece we have here */
TAILQ_FOREACH(overlap, &fsck_overlaps, next) {
opiece_len = udf_rw32(overlap->loc.len);
ostart_lb = udf_rw32(overlap->loc.loc.lb_num);
opartnr = udf_rw16(overlap->loc.loc.part_num);
oblocks = udf_bytes_to_sectors(opiece_len);
if (partnr != opartnr)
continue;
/* piece before overlap? */
if (start_lb + blocks < ostart_lb)
continue;
/* piece after overlap? */
if (start_lb > ostart_lb + oblocks)
continue;
/* overlap, mark conflict */
overlap->node2 = node;
overlap->flags2 = flags;
overlap->loc2.len = udf_rw32(piece_len);
overlap->loc2.loc.lb_num = udf_rw32(start_lb);
overlap->loc2.loc.part_num = udf_rw16(partnr);
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_OVERLAP;
}
return;
default:
errx(1, "internal error: bad mapping type %d in %s",
context.vtop_tp[partnr], __func__);
}
/* no overlap */
return;
}
static int
udf_process_ad(union dscrptr *dscrptr, int action, uint8_t **resultp,
int vpart_num, uint64_t fpos,
struct short_ad *short_adp, struct long_ad *long_adp, void *process_context)
{
struct file_entry *fe = &dscrptr->fe;
struct extfile_entry *efe = &dscrptr->efe;
struct desc_tag *tag = &dscrptr->tag;
struct icb_tag *icb;
struct udf_fsck_file_stats *stats;
uint64_t inf_len;
uint32_t l_ea, piece_len, piece_alloc_len, piece_sectors, lb_num, flags;
uint32_t dscr_lb_num;
uint32_t i;
uint8_t *bpos, *piece;
int id, ad_type;
int error, piece_error, return_error;
assert(dscrptr);
stats = (struct udf_fsck_file_stats *) process_context;
id = udf_rw16(tag->id);
assert(id == TAGID_FENTRY || id == TAGID_EXTFENTRY);
if (id == TAGID_FENTRY) {
icb = &fe->icbtag;
dscr_lb_num = udf_rw32(fe->tag.tag_loc);
inf_len = udf_rw64(fe->inf_len);
l_ea = udf_rw32(fe->l_ea);
bpos = (uint8_t *) fe->data + l_ea;
} else {
icb = &efe->icbtag;
dscr_lb_num = udf_rw32(efe->tag.tag_loc);
inf_len = udf_rw64(efe->inf_len);
l_ea = udf_rw32(efe->l_ea);
bpos = (uint8_t *) efe->data + l_ea;
}
lb_num = 0;
piece_len = 0;
ad_type = udf_rw16(icb->flags) & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
piece_len = inf_len;
}
if (short_adp) {
piece_len = udf_rw32(short_adp->len);
lb_num = udf_rw32(short_adp->lb_num);
}
if (long_adp) {
piece_len = udf_rw32(long_adp->len);
lb_num = udf_rw32(long_adp->loc.lb_num);
vpart_num = udf_rw16(long_adp->loc.part_num);
}
flags = UDF_EXT_FLAGS(piece_len);
piece_len = UDF_EXT_LEN(piece_len);
piece_alloc_len = UDF_ROUNDUP(piece_len, context.sector_size);
piece_sectors = piece_alloc_len / context.sector_size;
return_error = 0;
if (action & AD_GATHER_STATS) {
if (ad_type == UDF_ICB_INTERN_ALLOC) {
stats->inf_len = piece_len;
stats->obj_size = piece_len;
stats->logblks_rec = 0;
} else if (flags == UDF_EXT_ALLOCATED) {
stats->inf_len += piece_len;
stats->obj_size += piece_len;
stats->logblks_rec += piece_sectors;
} else if (flags == UDF_EXT_FREED) {
stats->inf_len += piece_len;
stats->obj_size += piece_len;
stats->logblks_rec += piece_sectors;
} else if (flags == UDF_EXT_FREE) {
stats->inf_len += piece_len;
stats->obj_size += piece_len;
}
}
if (action & AD_LOAD_FILE) {
uint32_t alloc_len;
piece = calloc(1, piece_alloc_len);
if (piece == NULL)
return errno;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
memcpy(piece, bpos, piece_len);
} else if (flags == 0) {
/* not empty */
/* read sector by sector reading as much as possible */
for (i = 0; i < piece_sectors; i++) {
piece_error = udf_read_virt(
piece + i * context.sector_size,
lb_num + i, vpart_num, 1);
if (piece_error)
return_error = piece_error;
}
}
alloc_len = UDF_ROUNDUP(fpos + piece_len, context.sector_size);
error = reallocarr(resultp, 1, alloc_len);
if (error) {
/* fatal */
free(piece);
free(*resultp);
return errno;
}
memcpy(*resultp + fpos, piece, piece_alloc_len);
free(piece);
}
if (action & AD_ADJUST_FIDS) {
piece = *resultp + fpos;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
udf_fids_fixup(piece, piece_len, process_context,
dscr_lb_num);
} else if (flags == 0) {
udf_fids_fixup(piece, piece_len, process_context,
lb_num);
}
}
if (action & AD_CHECK_FIDS) {
piece = *resultp + fpos;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
error = udf_quick_check_fids_piece(piece, piece_len,
process_context, dscr_lb_num);
} else if (flags == 0) {
error = udf_quick_check_fids_piece(piece, piece_len,
process_context, lb_num);
}
if (error)
return error;
}
if (action & AD_SAVE_FILE) {
/*
* Note: only used for directory contents.
*/
piece = *resultp + fpos;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
memcpy(bpos, piece, piece_len);
/* nothing */
} else if (flags == 0) {
/* not empty */
error = udf_write_virt(
piece, lb_num, vpart_num,
piece_sectors);
if (error) {
pwarn("Got error writing piece\n");
return error;
}
} else {
/* allocated but not written piece, skip */
}
}
if (action & AD_CHECK_USED) {
if (ad_type == UDF_ICB_INTERN_ALLOC) {
/* nothing */
} else if (flags != UDF_EXT_FREE) {
struct udf_fsck_node *node = process_context;
(void) udf_check_if_allocated(
node,
FSCK_OVERLAP_EXTENT,
lb_num, vpart_num,
piece_len);
}
}
if (action & AD_FIND_OVERLAP_PAIR) {
if (ad_type == UDF_ICB_INTERN_ALLOC) {
/* nothing */
} else if (flags != UDF_EXT_FREE) {
struct udf_fsck_node *node = process_context;
udf_check_overlap_pair(
node,
FSCK_OVERLAP_EXTENT,
lb_num, vpart_num,
piece_len);
}
}
if (action & AD_MARK_AS_USED) {
if (ad_type == UDF_ICB_INTERN_ALLOC) {
/* nothing */
} else if (flags != UDF_EXT_FREE) {
udf_mark_allocated(lb_num, vpart_num,
udf_bytes_to_sectors(piece_len));
}
}
return return_error;
}
static int
udf_process_file(union dscrptr *dscrptr, int vpart_num, uint8_t **resultp,
int action, void *process_context)
{
struct file_entry *fe = &dscrptr->fe;
struct extfile_entry *efe = &dscrptr->efe;
struct desc_tag *tag = &dscrptr->tag;
struct alloc_ext_entry *ext;
struct icb_tag *icb;
struct long_ad *long_adp = NULL;
struct short_ad *short_adp = NULL;
union dscrptr *extdscr = NULL;
uint64_t fpos;
uint32_t l_ad, l_ea, piece_len, lb_num, flags;
uint8_t *bpos;
int id, extid, ad_type, ad_len;
int error;
id = udf_rw16(tag->id);
assert(id == TAGID_FENTRY || id == TAGID_EXTFENTRY);
if (action & AD_CHECK_USED) {
struct udf_fsck_node *node = process_context;
(void) udf_check_if_allocated(
node,
FSCK_OVERLAP_MAIN_NODE,
udf_rw32(node->loc.loc.lb_num),
udf_rw16(node->loc.loc.part_num),
context.sector_size);
/* return error code? */
}
if (action & AD_FIND_OVERLAP_PAIR) {
struct udf_fsck_node *node = process_context;
udf_check_overlap_pair(
node,
FSCK_OVERLAP_MAIN_NODE,
udf_rw32(node->loc.loc.lb_num),
udf_rw16(node->loc.loc.part_num),
context.sector_size);
/* return error code? */
}
if (action & AD_MARK_AS_USED)
udf_mark_allocated(udf_rw32(tag->tag_loc), vpart_num, 1);
if (id == TAGID_FENTRY) {
icb = &fe->icbtag;
l_ad = udf_rw32(fe->l_ad);
l_ea = udf_rw32(fe->l_ea);
bpos = (uint8_t *) fe->data + l_ea;
} else {
icb = &efe->icbtag;
l_ad = udf_rw32(efe->l_ad);
l_ea = udf_rw32(efe->l_ea);
bpos = (uint8_t *) efe->data + l_ea;
}
ad_type = udf_rw16(icb->flags) & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
if (ad_type == UDF_ICB_INTERN_ALLOC) {
error = udf_process_ad(dscrptr, action, resultp, -1, 0,
NULL, NULL, process_context);
return error;
}
if ((ad_type != UDF_ICB_SHORT_ALLOC) &&
(ad_type != UDF_ICB_LONG_ALLOC))
return EINVAL;
if (ad_type == UDF_ICB_SHORT_ALLOC)
short_adp = (struct short_ad *) bpos;
else
long_adp = (struct long_ad *) bpos;
;
if (action & AD_SAVE_FILE) {
/*
* Special case for writeout file/directory on recordable
* media. We write in one go so wipe and (re)allocate the
* entire space.
*/
if (context.format_flags & FORMAT_VAT)
udf_wipe_and_reallocate(dscrptr, vpart_num, &l_ad);
}
fpos = 0;
bpos = NULL;
error = 0;
while (l_ad) {
if (ad_type == UDF_ICB_SHORT_ALLOC) {
piece_len = udf_rw32(short_adp->len);
lb_num = udf_rw32(short_adp->lb_num);
ad_len = sizeof(struct short_ad);
} else /* UDF_ICB_LONG_ALLOC */ {
piece_len = udf_rw32(long_adp->len);
lb_num = udf_rw32(long_adp->loc.lb_num);
vpart_num = udf_rw16(long_adp->loc.part_num);
ad_len = sizeof(struct long_ad);
}
flags = UDF_EXT_FLAGS(piece_len);
piece_len = UDF_EXT_LEN(piece_len);
switch (flags) {
default :
error = udf_process_ad(dscrptr, action, resultp,
vpart_num, fpos, short_adp, long_adp,
process_context);
break;
case UDF_EXT_REDIRECT :
if (piece_len != context.sector_size) {
/* should this be an error? */
pwarn("Got extension redirect with wrong size %d\n",
piece_len);
error = EINVAL;
break;
}
free(extdscr);
error = udf_read_dscr_virt(lb_num, vpart_num, &extdscr);
if (error)
break;
/* empty block is terminator */
if (extdscr == NULL)
return 0;
ext = &extdscr->aee;
extid = udf_rw16(ext->tag.id);
if (extid != TAGID_ALLOCEXTENT) {
pwarn("Corruption in allocated extents chain\n");
/* corruption! */
free(extdscr);
errno = EINVAL;
break;
}
if (action & AD_CHECK_USED) {
(void) udf_check_if_allocated(
(struct udf_fsck_node *) process_context,
FSCK_OVERLAP_EXTALLOC,
lb_num,
vpart_num,
context.sector_size);
/* returning error code ? */
}
if (action & AD_FIND_OVERLAP_PAIR) {
struct udf_fsck_node *node = process_context;
udf_check_overlap_pair(
node,
FSCK_OVERLAP_EXTALLOC,
lb_num,
vpart_num,
context.sector_size);
/* return error code? */
}
if (action & AD_MARK_AS_USED)
udf_mark_allocated(
lb_num, vpart_num,
1);
/* TODO check for prev_entry? */
l_ad = udf_rw32(ext->l_ad);
bpos = ext->data;
if (ad_type == UDF_ICB_SHORT_ALLOC)
short_adp = (struct short_ad *) bpos;
else
long_adp = (struct long_ad *) bpos;
;
continue;
}
if (error)
break;
if (long_adp) long_adp++;
if (short_adp) short_adp++;
fpos += piece_len;
bpos += piece_len;
l_ad -= ad_len;
}
return error;
}
static int
udf_readin_file(union dscrptr *dscrptr, int vpart_num, uint8_t **resultp,
struct udf_fsck_file_stats *statsp)
{
struct udf_fsck_file_stats stats;
int error;
bzero(&stats, sizeof(stats));
*resultp = NULL;
error = udf_process_file(dscrptr, vpart_num, resultp,
AD_LOAD_FILE | AD_GATHER_STATS, (void *) &stats);
if (statsp)
*statsp = stats;
return error;
}
/* --------------------------------------------------------------------- */
#define MAX_BSIZE (0x10000)
#define UDF_ISO_VRS_SIZE (32*2048) /* 32 ISO `sectors' */
static void
udf_check_vrs9660(void)
{
struct vrs_desc *vrs;
uint8_t buffer[MAX_BSIZE];
uint64_t rpos;
uint8_t *pos;
int max_sectors, sector, factor;
int ret, ok;
if (context.format_flags & FORMAT_TRACK512)
return;
/*
* location of iso9660 VRS is defined as first sector AFTER 32kb,
* minimum `sector size' 2048
*/
layout.iso9660_vrs = ((32*1024 + context.sector_size - 1) /
context.sector_size);
max_sectors = UDF_ISO_VRS_SIZE / 2048;
factor = (2048 + context.sector_size -1) / context.sector_size;
ok = 1;
rpos = (uint64_t) layout.iso9660_vrs * context.sector_size;
ret = pread(dev_fd, buffer, UDF_ISO_VRS_SIZE, rpos);
if (ret == -1) {
pwarn("Error reading in ISO9660 VRS\n");
ok = 0;
}
if (ok && ((uint32_t) ret != UDF_ISO_VRS_SIZE)) {
pwarn("Short read in ISO9660 VRS\n");
ok = 0;
}
if (ok) {
ok = 0;
for (sector = 0; sector < max_sectors; sector++) {
pos = buffer + sector * factor * context.sector_size;
vrs = (struct vrs_desc *) pos;
if (strncmp((const char *) vrs->identifier, VRS_BEA01, 5) == 0)
ok = 1;
if (strncmp((const char *) vrs->identifier, VRS_NSR02, 5) == 0)
ok |= 2;
if (strncmp((const char *) vrs->identifier, VRS_NSR03, 5) == 0)
ok |= 2;
if (strncmp((const char *) vrs->identifier, VRS_TEA01, 5) == 0) {
ok |= 4;
break;
}
}
if (ok != 7)
ok = 0;
}
if (!ok) {
pwarn("Error in ISO 9660 volume recognition sequence\n");
if (context.format_flags & FORMAT_SEQUENTIAL) {
pwarn("ISO 9660 volume recognition sequence can't be repaired "
"on SEQUENTIAL media\n");
} else if (ask(0, "fix ISO 9660 volume recognition sequence")) {
if (!rdonly)
udf_write_iso9660_vrs();
}
}
}
/*
* Read in disc and try to find basic properties like sector size, expected
* UDF versions etc.
*/
static int
udf_find_anchor(int anum)
{
uint8_t buffer[MAX_BSIZE];
struct anchor_vdp *avdp = (struct anchor_vdp *) buffer;
uint64_t rpos;
uint32_t location;
int sz_guess, ret;
int error;
location = layout.anchors[anum];
/*
* Search ADVP by reading bigger and bigger sectors NOTE we can't use
* udf_read_phys yet since the sector size is not known yet
*/
sz_guess = mmc_discinfo.sector_size; /* assume media is bigger */
for (; sz_guess <= MAX_BSIZE; sz_guess += 512) {
rpos = (uint64_t) location * sz_guess;
ret = pread(dev_fd, buffer, sz_guess, rpos);
if (ret == -1) {
if (errno == ENODEV)
return errno;
} else if (ret != sz_guess) {
/* most likely EOF, ignore */
} else {
error = udf_check_tag_and_location(buffer, location);
if (!error) {
if (udf_rw16(avdp->tag.id) != TAGID_ANCHOR)
continue;
error = udf_check_tag_payload(buffer, sz_guess);
if (!error)
break;
}
}
}
if (sz_guess > MAX_BSIZE)
return -1;
/* special case for disc images */
if (mmc_discinfo.sector_size != (unsigned int) sz_guess) {
emul_sectorsize = sz_guess;
udf_update_discinfo();
}
context.sector_size = sz_guess;
context.dscrver = udf_rw16(avdp->tag.descriptor_ver);
context.anchors[anum] = calloc(1, context.sector_size);
memcpy(context.anchors[anum], avdp, context.sector_size);
context.min_udf = 0x102;
context.max_udf = 0x150;
if (context.dscrver > 2) {
context.min_udf = 0x200;
context.max_udf = 0x260;
}
return 0;
}
static int
udf_get_anchors(void)
{
struct mmc_trackinfo ti;
struct anchor_vdp *avdp;
int need_fixup, error;
memset(&layout, 0, sizeof(layout));
memset(&ti, 0, sizeof(ti));
/* search start */
for (int i = 1; i <= mmc_discinfo.num_tracks; i++) {
ti.tracknr = i;
error = udf_update_trackinfo(&ti);
assert(!error);
if (ti.sessionnr == target_session)
break;
}
/* support for track 512 */
if (ti.flags & MMC_TRACKINFO_BLANK)
context.format_flags |= FORMAT_TRACK512;
assert(!error);
context.first_ti = ti;
/* search end */
for (int i = mmc_discinfo.num_tracks; i > 0; i--) {
ti.tracknr = i;
error = udf_update_trackinfo(&ti);
assert(!error);
if (ti.sessionnr == target_session)
break;
}
context.last_ti = ti;
layout.first_lba = context.first_ti.track_start;
layout.last_lba = mmc_discinfo.last_possible_lba;
layout.blockingnr = udf_get_blockingnr(&ti);
layout.anchors[0] = layout.first_lba + 256;
if (context.format_flags & FORMAT_TRACK512)
layout.anchors[0] = layout.first_lba + 512;
layout.anchors[1] = layout.last_lba - 256;
layout.anchors[2] = layout.last_lba;
need_fixup = 0;
error = udf_find_anchor(0);
if (error == ENODEV) {
pwarn("Drive empty?\n");
return errno;
}
if (error) {
need_fixup = 1;
if (!preen)
pwarn("Anchor ADVP0 can't be found! Searching others\n");
error = udf_find_anchor(2);
if (error) {
if (!preen)
pwarn("Anchor ADVP2 can't be found! Searching ADVP1\n");
/* this may be fidly, but search */
error = udf_find_anchor(1);
if (error) {
if (!preen)
pwarn("No valid anchors found!\n");
/* TODO scan media for VDS? */
return -1;
}
}
}
if (need_fixup) {
if (context.format_flags & FORMAT_SEQUENTIAL) {
pwarn("Missing primary anchor can't be resolved on "
"SEQUENTIAL media\n");
} else if (ask(1, "Fixup missing anchors")) {
pwarn("TODO fixup missing anchors\n");
need_fixup = 0;
}
if (need_fixup)
return -1;
}
if (!preen)
printf("Filesystem sectorsize is %d bytes.\n\n",
context.sector_size);
/* update our last track info since our idea of sector size might have changed */
(void) udf_update_trackinfo(&context.last_ti);
/* sector size is now known */
wrtrack_skew = context.last_ti.next_writable % layout.blockingnr;
avdp = context.anchors[0];
/* extract info from current anchor */
layout.vds1 = udf_rw32(avdp->main_vds_ex.loc);
layout.vds1_size = udf_rw32(avdp->main_vds_ex.len) / context.sector_size;
layout.vds2 = udf_rw32(avdp->reserve_vds_ex.loc);
layout.vds2_size = udf_rw32(avdp->reserve_vds_ex.len) / context.sector_size;
return 0;
}
#define UDF_LVINT_HIST_CHUNK 32
static void
udf_retrieve_lvint(void) {
union dscrptr *dscr;
struct logvol_int_desc *lvint;
struct udf_lvintq *trace;
uint32_t lbnum, len, *pos;
uint8_t *wpos;
int num_partmappings;
int error, cnt, trace_len;
int sector_size = context.sector_size;
len = udf_rw32(context.logical_vol->integrity_seq_loc.len);
lbnum = udf_rw32(context.logical_vol->integrity_seq_loc.loc);
layout.lvis = lbnum;
layout.lvis_size = len / sector_size;
udf_create_lvintd(UDF_INTEGRITY_OPEN);
/* clean trace and history */
memset(context.lvint_trace, 0,
UDF_LVDINT_SEGMENTS * sizeof(struct udf_lvintq));
context.lvint_history_wpos = 0;
context.lvint_history_len = UDF_LVINT_HIST_CHUNK;
context.lvint_history = calloc(UDF_LVINT_HIST_CHUNK, sector_size);
/* record the length on this segment */
context.lvint_history_ondisc_len = (len / sector_size);
trace_len = 0;
trace = context.lvint_trace;
trace->start = lbnum;
trace->end = lbnum + len/sector_size;
trace->pos = 0;
trace->wpos = 0;
dscr = NULL;
error = 0;
while (len) {
trace->pos = lbnum - trace->start;
trace->wpos = trace->pos + 1;
free(dscr);
error = udf_read_dscr_phys(lbnum, &dscr);
/* bad descriptors mean corruption, terminate */
if (error)
break;
/* empty terminates */
if (dscr == NULL) {
trace->wpos = trace->pos;
break;
}
/* we got a valid descriptor */
if (udf_rw16(dscr->tag.id) == TAGID_TERM) {
trace->wpos = trace->pos;
break;
}
/* only logical volume integrity descriptors are valid */
if (udf_rw16(dscr->tag.id) != TAGID_LOGVOL_INTEGRITY) {
error = ENOENT;
break;
}
lvint = &dscr->lvid;
/* see if our history is long enough, with one spare */
if (context.lvint_history_wpos+2 >= context.lvint_history_len) {
int new_len = context.lvint_history_len +
UDF_LVINT_HIST_CHUNK;
if (reallocarr(&context.lvint_history,
new_len, sector_size))
err(FSCK_EXIT_CHECK_FAILED, "can't expand logvol history");
context.lvint_history_len = new_len;
}
/* are we linking to a new piece? */
if (lvint->next_extent.len) {
len = udf_rw32(lvint->next_extent.len);
lbnum = udf_rw32(lvint->next_extent.loc);
if (trace_len >= UDF_LVDINT_SEGMENTS-1) {
/* IEK! segment link full... */
pwarn("implementation limit: logical volume "
"integrity segment list full\n");
error = ENOMEM;
break;
}
trace++;
trace_len++;
trace->start = lbnum;
trace->end = lbnum + len/sector_size;
trace->pos = 0;
trace->wpos = 0;
context.lvint_history_ondisc_len += (len / sector_size);
}
/* record this found lvint; it is one sector long */
wpos = context.lvint_history +
context.lvint_history_wpos * sector_size;
memcpy(wpos, dscr, sector_size);
memcpy(context.logvol_integrity, dscr, sector_size);
context.lvint_history_wpos++;
/* proceed sequential */
lbnum += 1;
len -= sector_size;
}
/* clean up the mess, esp. when there is an error */
free(dscr);
if (error) {
if (!preen)
printf("Error in logical volume integrity sequence\n");
printf("Marking logical volume integrity OPEN\n");
udf_update_lvintd(UDF_INTEGRITY_OPEN);
}
if (udf_rw16(context.logvol_info->min_udf_readver) > context.min_udf)
context.min_udf = udf_rw16(context.logvol_info->min_udf_readver);
if (udf_rw16(context.logvol_info->min_udf_writever) > context.min_udf)
context.min_udf = udf_rw16(context.logvol_info->min_udf_writever);
if (udf_rw16(context.logvol_info->max_udf_writever) < context.max_udf)
context.max_udf = udf_rw16(context.logvol_info->max_udf_writever);
context.unique_id = udf_rw64(context.logvol_integrity->lvint_next_unique_id);
/* fill in current size/free values */
pos = &context.logvol_integrity->tables[0];
num_partmappings = udf_rw32(context.logical_vol->n_pm);
for (cnt = 0; cnt < num_partmappings; cnt++) {
context.part_free[cnt] = udf_rw32(*pos);
pos++;
}
/* leave the partition sizes alone; no idea why they are stated here */
/* TODO sanity check the free space and partition sizes? */
/* XXX FAULT INJECTION POINT XXX */
//udf_update_lvintd(UDF_INTEGRITY_OPEN);
if (!preen) {
int ver;
printf("\n");
ver = udf_rw16(context.logvol_info->min_udf_readver);
printf("Minimum read version v%x.%02x\n", ver/0x100, ver&0xff);
ver = udf_rw16(context.logvol_info->min_udf_writever);
printf("Minimum write version v%x.%02x\n", ver/0x100, ver&0xff);
ver = udf_rw16(context.logvol_info->max_udf_writever);
printf("Maximum write version v%x.%02x\n", ver/0x100, ver&0xff);
printf("\nLast logical volume integrity state is %s.\n",
udf_rw32(context.logvol_integrity->integrity_type) ?
"CLOSED" : "OPEN");
}
}
static int
udf_writeout_lvint(void)
{
union dscrptr *terminator;
struct udf_lvintq *intq, *nintq;
struct logvol_int_desc *lvint;
uint32_t location;
int wpos, num_avail;
int sector_size = context.sector_size;
int integrity_type, error;
int next_present, end_slot, last_segment;
/* only write out when its open */
integrity_type = udf_rw32(context.logvol_integrity->integrity_type);
if (integrity_type == UDF_INTEGRITY_CLOSED)
return 0;
if (!preen)
printf("\n");
if (!ask(1, "Write out modifications"))
return 0;
udf_allow_writing();
/* close logical volume */
udf_update_lvintd(UDF_INTEGRITY_CLOSED);
/* do we need to lose some history? */
if ((context.lvint_history_ondisc_len - context.lvint_history_wpos) < 2) {
uint8_t *src, *dst;
uint32_t size;
dst = context.lvint_history;
src = dst + sector_size;
size = (context.lvint_history_wpos-2) * sector_size;
memmove(dst, src, size);
context.lvint_history_wpos -= 2;
}
/* write out complete trace just in case */
wpos = 0;
location = 0;
for (int i = 0; i < UDF_LVDINT_SEGMENTS; i++) {
intq = &context.lvint_trace[i];
nintq = &context.lvint_trace[i+1];
/* end of line? */
if (intq->start == intq->end)
break;
num_avail = intq->end - intq->start;
location = intq->start;
for (int sector = 0; sector < num_avail; sector++) {
lvint = (struct logvol_int_desc *)
(context.lvint_history + wpos * sector_size);
memset(&lvint->next_extent, 0, sizeof(struct extent_ad));
next_present = (wpos != context.lvint_history_wpos);
end_slot = (sector == num_avail -1);
last_segment = (i == UDF_LVDINT_SEGMENTS-1);
if (end_slot && next_present && !last_segment) {
/* link to next segment */
lvint->next_extent.len = udf_rw32(
sector_size * (nintq->end - nintq->start));
lvint->next_extent.loc = udf_rw32(nintq->start);
}
error = udf_write_dscr_phys((union dscrptr *) lvint, location, 1);
assert(!error);
wpos++;
location++;
if (wpos == context.lvint_history_wpos)
break;
}
}
/* at write pos, write out our integrity */
assert(location);
lvint = context.logvol_integrity;
error = udf_write_dscr_phys((union dscrptr *) lvint, location, 1);
assert(!error);
wpos++;
location++;
/* write out terminator */
terminator = calloc(1, context.sector_size);
assert(terminator);
udf_create_terminator(terminator, 0);
/* same or increasing serial number: ECMA 3/7.2.5, 4/7.2.5, UDF 2.3.1.1. */
terminator->tag.serial_num = lvint->tag.serial_num;
error = udf_write_dscr_phys(terminator, location, 1);
free(terminator);
assert(!error);
wpos++;
location++;
return 0;
}
static int
udf_readin_partitions_free_space(void)
{
union dscrptr *dscr;
struct part_desc *part;
struct part_hdr_desc *phd;
uint32_t bitmap_len, bitmap_lb;
int cnt, tagid, error;
/* XXX freed space bitmap ignored XXX */
error = 0;
for (cnt = 0; cnt < UDF_PARTITIONS; cnt++) {
part = context.partitions[cnt];
if (!part)
continue;
phd = &part->pd_part_hdr;
bitmap_len = udf_rw32(phd->unalloc_space_bitmap.len);
bitmap_lb = udf_rw32(phd->unalloc_space_bitmap.lb_num);
if (bitmap_len == 0) {
error = 0;
continue;
}
if (!preen)
printf("Reading in free space map for partition %d\n", cnt);
error = udf_read_dscr_virt(bitmap_lb, cnt, &dscr);
if (error)
break;
if (!dscr) {
error = ENOENT;
break;
}
tagid = udf_rw16(dscr->tag.id);
if (tagid != TAGID_SPACE_BITMAP) {
pwarn("Unallocated space bitmap expected but got "
"tag %d\n", tagid);
free(dscr);
error = ENOENT;
break;
}
if (udf_tagsize(dscr, context.sector_size) > bitmap_len) {
pwarn("Warning, size of read in bitmap %d is "
"not equal to expected size %d\n",
udf_tagsize(dscr, context.sector_size),
bitmap_len);
}
context.part_unalloc_bits[cnt] = &dscr->sbd;
}
/* special case for metadata partitions */
for (cnt = 0; cnt < UDF_PMAPS; cnt++) {
if (context.vtop_tp[cnt] != UDF_VTOP_TYPE_META)
continue;
/* only if present */
if (layout.meta_bitmap == 0xffffffff)
continue;
if (!preen)
printf("Reading in free space map for partition %d\n", cnt);
error = udf_readin_file(
(union dscrptr *) context.meta_bitmap,
context.vtop[cnt],
(uint8_t **) &context.part_unalloc_bits[cnt],
NULL);
if (error) {
free(context.part_unalloc_bits[cnt]);
context.part_unalloc_bits[cnt] = NULL;
pwarn("implementation limit: metadata bitmap file read error, "
"can't fix this up yet\n");
return error;
}
}
if (!preen)
printf("\n");
return error;
}
/* ------------------------- VAT support ------------------------- */
/*
* Update logical volume name in all structures that keep a record of it. We
* use memmove since each of them might be specified as a source.
*
* Note that it doesn't update the VAT structure!
*/
static void
udf_update_logvolname(char *logvol_id)
{
struct logvol_desc *lvd = NULL;
struct fileset_desc *fsd = NULL;
struct udf_lv_info *lvi = NULL;
lvd = context.logical_vol;
fsd = context.fileset_desc;
if (context.implementation)
lvi = &context.implementation->_impl_use.lv_info;
/* logvol's id might be specified as original so use memmove here */
memmove(lvd->logvol_id, logvol_id, 128);
if (fsd)
memmove(fsd->logvol_id, logvol_id, 128);
if (lvi)
memmove(lvi->logvol_id, logvol_id, 128);
}
static struct timestamp *
udf_file_mtime(union dscrptr *dscr)
{
int tag_id = udf_rw16(dscr->tag.id);
assert((tag_id == TAGID_FENTRY) || (tag_id == TAGID_EXTFENTRY));
if (tag_id == TAGID_FENTRY)
return &dscr->fe.mtime;
else
return &dscr->efe.mtime;
;
}
static void
udf_print_vat_details(union dscrptr *dscr)
{
printf("\n");
udf_print_timestamp("\tFound VAT timestamped at ",
udf_file_mtime(dscr), "\n");
}
static int
udf_check_for_vat(union dscrptr *dscr)
{
struct icb_tag *icbtag;
uint32_t vat_length;
int tag_id, filetype;
tag_id = udf_rw16(dscr->tag.id);
if ((tag_id != TAGID_FENTRY) && (tag_id != TAGID_EXTFENTRY))
return ENOENT;
if (tag_id == TAGID_FENTRY) {
vat_length = udf_rw64(dscr->fe.inf_len);
icbtag = &dscr->fe.icbtag;
} else {
vat_length = udf_rw64(dscr->efe.inf_len);
icbtag = &dscr->efe.icbtag;
}
filetype = icbtag->file_type;
if ((filetype != 0) && (filetype != UDF_ICB_FILETYPE_VAT))
return ENOENT;
/* TODO sanity check vat length */
(void)vat_length;
return 0;
}
static int
udf_extract_vat(union dscrptr *dscr, uint8_t **vat_contents)
{
struct udf_fsck_file_stats stats;
struct icb_tag *icbtag;
struct timestamp *mtime;
struct udf_vat *vat;
struct udf_oldvat_tail *oldvat_tl;
struct udf_logvol_info *lvinfo;
struct impl_extattr_entry *implext;
struct vatlvext_extattr_entry lvext;
const char *extstr = "*UDF VAT LVExtension";
uint64_t vat_unique_id;
uint64_t vat_length;
uint32_t vat_entries, vat_offset;
uint32_t offset, a_l;
uint8_t *ea_start, *lvextpos;
char *regid_name;
int tag_id, filetype;
int error;
*vat_contents = NULL;
lvinfo = context.logvol_info;
/* read in VAT contents */
error = udf_readin_file(dscr, context.data_part, vat_contents, &stats);
if (error) {
error = ENOENT;
goto out;
}
/* tag_id already checked */
tag_id = udf_rw16(dscr->tag.id);
if (tag_id == TAGID_FENTRY) {
vat_length = udf_rw64(dscr->fe.inf_len);
icbtag = &dscr->fe.icbtag;
mtime = &dscr->fe.mtime;
vat_unique_id = udf_rw64(dscr->fe.unique_id);
ea_start = dscr->fe.data;
} else {
vat_length = udf_rw64(dscr->efe.inf_len);
icbtag = &dscr->efe.icbtag;
mtime = &dscr->efe.mtime;
vat_unique_id = udf_rw64(dscr->efe.unique_id);
ea_start = dscr->efe.data; /* for completion */
}
if (vat_length > stats.inf_len) {
error = ENOENT;
goto out;
}
/* file type already checked */
filetype = icbtag->file_type;
/* extract info from our VAT data */
if (filetype == 0) {
/* VAT 1.50 format */
/* definition */
vat_offset = 0;
vat_entries = (vat_length-36)/4;
oldvat_tl = (struct udf_oldvat_tail *)
(*vat_contents + vat_entries * 4);
regid_name = (char *) oldvat_tl->id.id;
error = strncmp(regid_name, "*UDF Virtual Alloc Tbl", 22);
if (error) {
pwarn("Possible VAT 1.50 detected without tail\n");
if (ask_noauto(0, "Accept anyway")) {
vat_entries = vat_length/4;
vat_writeout = 1;
error = 0;
goto ok;
}
pwarn("VAT format 1.50 rejected\n");
error = ENOENT;
goto out;
}
/*
* The following VAT extensions are optional and ignored but
* demand a clean VAT write out for sanity.
*/
error = udf_extattr_search_intern(dscr, 2048, extstr, &offset, &a_l);
if (error) {
/* VAT LVExtension extended attribute missing */
error = 0;
vat_writeout = 1;
goto ok;
}
implext = (struct impl_extattr_entry *) (ea_start + offset);
error = udf_impl_extattr_check(implext);
if (error) {
/* VAT LVExtension checksum failed */
error = 0;
vat_writeout = 1;
goto ok;
}
/* paranoia */
if (a_l != sizeof(*implext) -2 + udf_rw32(implext->iu_l) + sizeof(lvext)) {
/* VAT LVExtension size doesn't compute */
error = 0;
vat_writeout = 1;
goto ok;
}
/*
* We have found our "VAT LVExtension attribute. BUT due to a
* bug in the specification it might not be word aligned so
* copy first to avoid panics on some machines (!!)
*/
lvextpos = implext->data + udf_rw32(implext->iu_l);
memcpy(&lvext, lvextpos, sizeof(lvext));
/* check if it was updated the last time */
if (udf_rw64(lvext.unique_id_chk) == vat_unique_id) {
lvinfo->num_files = lvext.num_files;
lvinfo->num_directories = lvext.num_directories;
udf_update_logvolname(lvext.logvol_id);
} else {
/* VAT LVExtension out of date */
vat_writeout = 1;
}
} else {
/* VAT 2.xy format */
/* definition */
vat = (struct udf_vat *) (*vat_contents);
vat_offset = udf_rw16(vat->header_len);
vat_entries = (vat_length - vat_offset)/4;
if (heuristics) {
if (vat->impl_use_len == 0) {
uint32_t start_val;
start_val = udf_rw32(*((uint32_t *) vat->data));
if (start_val == 0x694d2a00) {
/* "<0>*Mic"osoft Windows */
pwarn("Heuristics found corrupted MS Windows VAT\n");
if (ask(0, "Repair")) {
vat->impl_use_len = udf_rw16(32);
vat->header_len = udf_rw16(udf_rw16(vat->header_len) + 32);
vat_offset += 32;
vat_writeout = 1;
}
}
}
}
assert(lvinfo);
lvinfo->num_files = vat->num_files;
lvinfo->num_directories = vat->num_directories;
lvinfo->min_udf_readver = vat->min_udf_readver;
lvinfo->min_udf_writever = vat->min_udf_writever;
lvinfo->max_udf_writever = vat->max_udf_writever;
udf_update_logvolname(vat->logvol_id);
}
/* XXX FAULT INJECTION POINT XXX */
//vat_writeout = 1;
ok:
/* extra sanity checking */
if (tag_id == TAGID_FENTRY) {
/* nothing checked as yet */
} else {
/*
* The following VAT violations are ignored but demand a clean VAT
* writeout for sanity
*/
if (!is_zero(&dscr->efe.streamdir_icb, sizeof(struct long_ad))) {
/* VAT specification violation:
* VAT has no cleared streamdir reference */
vat_writeout = 1;
}
if (!is_zero(&dscr->efe.ex_attr_icb, sizeof(struct long_ad))) {
/* VAT specification violation:
* VAT has no cleared extended attribute reference */
vat_writeout = 1;
}
if (dscr->efe.obj_size != dscr->efe.inf_len) {
/* VAT specification violation:
* VAT has invalid object size */
vat_writeout = 1;
}
}
if (!vat_writeout) {
context.logvol_integrity->lvint_next_unique_id = udf_rw64(vat_unique_id);
context.logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_CLOSED);
context.logvol_integrity->time = *mtime;
}
context.unique_id = vat_unique_id;
context.vat_allocated = UDF_ROUNDUP(vat_length, context.sector_size);
context.vat_contents = *vat_contents;
context.vat_start = vat_offset;
context.vat_size = vat_offset + vat_entries * 4;
out:
if (error) {
free(*vat_contents);
*vat_contents = NULL;
}
return error;
}
#define VAT_BLK 256
static int
udf_search_vat(union udf_pmap *mapping, int log_part)
{
union dscrptr *vat_candidate, *accepted_vat;
struct part_desc *pdesc;
struct mmc_trackinfo *ti, *ti_s;
uint32_t part_start;
uint32_t vat_loc, early_vat_loc, late_vat_loc, accepted_vat_loc;
uint32_t first_possible_vat_location, last_possible_vat_location;
uint8_t *vat_contents, *accepted_vat_contents;
int num_tracks, tracknr, found_a_VAT, valid_loc, error;
/*
* Start reading forward in blocks from the first possible vat
* location. If not found in this block, start again a bit before
* until we get a hit.
*/
/* get complete list of all our valid ranges */
ti_s = calloc(mmc_discinfo.num_tracks, sizeof(struct mmc_trackinfo));
for (tracknr = 1; tracknr <= mmc_discinfo.num_tracks; tracknr++) {
ti = &ti_s[tracknr];
ti->tracknr = tracknr;
(void) udf_update_trackinfo(ti);
}
/* derive our very first track number our base partition covers */
pdesc = context.partitions[context.data_part];
part_start = udf_rw32(pdesc->start_loc);
for (int cnt = 0; cnt < UDF_PARTITIONS; cnt++) {
pdesc = context.partitions[cnt];
if (!pdesc)
continue;
part_start = MIN(part_start, udf_rw32(pdesc->start_loc));
}
num_tracks = mmc_discinfo.num_tracks;
for (tracknr = 1, ti = NULL; tracknr <= num_tracks; tracknr++) {
ti = &ti_s[tracknr];
if ((part_start >= ti->track_start) &&
(part_start <= ti->track_start + ti->track_size))
break;
}
context.first_ti_partition = *ti;
first_possible_vat_location = context.first_ti_partition.track_start;
last_possible_vat_location = context.last_ti.track_start +
context.last_ti.track_size -
context.last_ti.free_blocks + 1;
/* initial guess is around 16 sectors back */
late_vat_loc = last_possible_vat_location;
early_vat_loc = MAX(late_vat_loc - 16, first_possible_vat_location);
if (!preen)
printf("Full VAT range search from %d to %d\n",
first_possible_vat_location,
last_possible_vat_location);
vat_writeout = 0;
accepted_vat = NULL;
accepted_vat_contents = NULL;
accepted_vat_loc = 0;
do {
vat_loc = early_vat_loc;
if (!preen) {
printf("\tChecking range %8d to %8d\n",
early_vat_loc, late_vat_loc);
fflush(stdout);
}
found_a_VAT = 0;
while (vat_loc <= late_vat_loc) {
if (print_info) {
pwarn("\nchecking for VAT in sector %8d\n", vat_loc);
print_info = 0;
}
/* check if its in readable range */
valid_loc = 0;
for (tracknr = 1; tracknr <= num_tracks; tracknr++) {
ti = &ti_s[tracknr];
if (!(ti->flags & MMC_TRACKINFO_BLANK) &&
((vat_loc >= ti->track_start) &&
(vat_loc <= ti->track_start + ti->track_size))) {
valid_loc = 1;
break;
}
}
if (!valid_loc) {
vat_loc++;
continue;
}
error = udf_read_dscr_phys(vat_loc, &vat_candidate);
if (!vat_candidate)
error = ENOENT;
if (!error)
error = udf_check_for_vat(vat_candidate);
if (error) {
vat_loc++; /* walk forward */
continue;
}
if (accepted_vat) {
/* check if newer vat time stamp is the same */
if (udf_compare_mtimes(
udf_file_mtime(vat_candidate),
udf_file_mtime(accepted_vat)
) == 0) {
free(vat_candidate);
vat_loc++; /* walk forward */
continue;
}
}
/* check if its contents are OK */
error = udf_extract_vat(
vat_candidate, &vat_contents);
if (error) {
/* unlikely */
// pwarn("Unreadable or malformed VAT encountered\n");
free(vat_candidate);
vat_loc++;
continue;
}
/* accept new vat */
free(accepted_vat);
free(accepted_vat_contents);
accepted_vat = vat_candidate;
accepted_vat_contents = vat_contents;
accepted_vat_loc = vat_loc;
vat_candidate = NULL;
vat_contents = NULL;
found_a_VAT = 1;
vat_loc++; /* walk forward */
};
if (found_a_VAT && accepted_vat) {
/* VAT accepted */
if (!preen)
udf_print_vat_details(accepted_vat);
if (vat_writeout)
pwarn("\tVAT accepted but marked dirty\n");
if (!preen && !vat_writeout)
pwarn("\tLogical volume integrity state set to CLOSED\n");
if (!search_older_vat)
break;
if (!ask_noauto(0, "\tSearch older VAT"))
break;
late_vat_loc = accepted_vat_loc - 1;
} else {
late_vat_loc = early_vat_loc - 1;
}
if (early_vat_loc == first_possible_vat_location)
break;
early_vat_loc = first_possible_vat_location;
if (late_vat_loc > VAT_BLK)
early_vat_loc = MAX(early_vat_loc, late_vat_loc - VAT_BLK);
} while (late_vat_loc > first_possible_vat_location);
if (!preen)
printf("\n");
undo_opening_session = 0;
if (!accepted_vat) {
if ((context.last_ti.sessionnr > 1) &&
ask_noauto(0, "Undo opening of last session")) {
undo_opening_session = 1;
pwarn("Undoing opening of last session not implemented!\n");
error = ENOENT;
goto error_out;
} else {
pwarn("No valid VAT found!\n");
error = ENOENT;
goto error_out;
}
}
if (last_possible_vat_location - accepted_vat_loc > 16) {
assert(accepted_vat);
pwarn("Selected VAT is not the latest or not at the end of "
"track.\n");
vat_writeout = 1;
}
/* XXX FAULT INJECTION POINT XXX */
//vat_writeout = 1;
//udf_update_lvintd(UDF_INTEGRITY_OPEN);
return 0;
error_out:
free(accepted_vat);
free(accepted_vat_contents);
return error;
}
/* ------------------------- sparables support ------------------------- */
static int
udf_read_spareables(union udf_pmap *mapping, int log_part)
{
union dscrptr *dscr;
struct part_map_spare *pms = &mapping->pms;
uint32_t lb_num;
int spar, error;
for (spar = 0; spar < pms->n_st; spar++) {
lb_num = pms->st_loc[spar];
error = udf_read_dscr_phys(lb_num, &dscr);
if (error && !preen)
pwarn("Error reading spareable table %d\n", spar);
if (!error && dscr) {
if (udf_rw16(dscr->tag.id) == TAGID_SPARING_TABLE) {
free(context.sparing_table);
context.sparing_table = &dscr->spt;
dscr = NULL;
break; /* we're done */
}
}
free(dscr);
}
if (context.sparing_table == NULL)
return ENOENT;
return 0;
}
/* ------------------------- metadata support ------------------------- */
static bool
udf_metadata_node_supported(void)
{
struct extfile_entry *efe;
struct short_ad *short_ad;
uint32_t len;
uint32_t flags;
uint8_t *data_pos;
int dscr_size, l_ea, l_ad, icbflags, addr_type;
/* we have to look into the file's allocation descriptors */
efe = context.meta_file;
dscr_size = sizeof(struct extfile_entry) - 1;
l_ea = udf_rw32(efe->l_ea);
l_ad = udf_rw32(efe->l_ad);
icbflags = udf_rw16(efe->icbtag.flags);
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
if (addr_type != UDF_ICB_SHORT_ALLOC) {
warnx("specification violation: metafile not using"
"short allocs");
return false;
}
data_pos = (uint8_t *) context.meta_file + dscr_size + l_ea;
short_ad = (struct short_ad *) data_pos;
while (l_ad > 0) {
len = udf_rw32(short_ad->len);
flags = UDF_EXT_FLAGS(len);
if (flags == UDF_EXT_REDIRECT) {
warnx("implementation limit: no support for "
"extent redirections in metadata file");
return false;
}
short_ad++;
l_ad -= sizeof(struct short_ad);
}
/* we passed all of them */
return true;
}
static int
udf_read_metadata_nodes(union udf_pmap *mapping, int log_part)
{
union dscrptr *dscr1, *dscr2, *dscr3;
struct part_map_meta *pmm = &mapping->pmm;
uint16_t raw_phys_part, phys_part;
int tagid, file_type, error;
/*
* BUGALERT: some rogue implementations use random physical
* partition numbers to break other implementations so lookup
* the number.
*/
raw_phys_part = udf_rw16(pmm->part_num);
phys_part = udf_find_raw_phys(raw_phys_part);
error = udf_read_dscr_virt(layout.meta_file, phys_part, &dscr1);
if (!error) {
tagid = udf_rw16(dscr1->tag.id);
file_type = dscr1->efe.icbtag.file_type;
if ((tagid != TAGID_EXTFENTRY) ||
(file_type != UDF_ICB_FILETYPE_META_MAIN))
error = ENOENT;
}
if (error) {
pwarn("Bad primary metadata file descriptor\n");
free(dscr1);
dscr1 = NULL;
}
error = udf_read_dscr_virt(layout.meta_mirror, phys_part, &dscr2);
if (!error) {
tagid = udf_rw16(dscr2->tag.id);
file_type = dscr2->efe.icbtag.file_type;
if ((tagid != TAGID_EXTFENTRY) ||
(file_type != UDF_ICB_FILETYPE_META_MIRROR))
error = ENOENT;
}
if (error) {
pwarn("Bad mirror metadata file descriptor\n");
free(dscr2);
dscr2 = NULL;
}
if ((dscr1 == NULL) && (dscr2 == NULL)) {
pwarn("No valid metadata file descriptors found!\n");
return -1;
}
error = 0;
if ((dscr1 == NULL) && dscr2) {
dscr1 = malloc(context.sector_size);
memcpy(dscr1, dscr2, context.sector_size);
dscr1->efe.icbtag.file_type = UDF_ICB_FILETYPE_META_MAIN;
if (ask(1, "Fix up bad primary metadata file descriptor")) {
error = udf_write_dscr_virt(dscr1,
layout.meta_file, phys_part, 1);
}
}
if (dscr1 && (dscr2 == NULL)) {
dscr2 = malloc(context.sector_size);
memcpy(dscr2, dscr1, context.sector_size);
dscr2->efe.icbtag.file_type = UDF_ICB_FILETYPE_META_MIRROR;
if (ask(1, "Fix up bad mirror metadata file descriptor")) {
error = udf_write_dscr_virt(dscr2,
layout.meta_mirror, phys_part, 1);
}
}
if (error)
pwarn("Copying metadata file descriptor failed, "
"trying to continue\n");
context.meta_file = &dscr1->efe;
context.meta_mirror = &dscr2->efe;
dscr3 = NULL;
if (layout.meta_bitmap != 0xffffffff) {
error = udf_read_dscr_virt(layout.meta_bitmap, phys_part, &dscr3);
if (!error) {
tagid = udf_rw16(dscr3->tag.id);
file_type = dscr3->efe.icbtag.file_type;
if ((tagid != TAGID_EXTFENTRY) ||
(file_type != UDF_ICB_FILETYPE_META_BITMAP))
error = ENOENT;
}
if (error) {
pwarn("Bad metadata bitmap file descriptor\n");
free(dscr3);
dscr3 = NULL;
}
if (dscr3 == NULL) {
pwarn("implementation limit: can't repair missing or "
"damaged metadata bitmap descriptor\n");
return -1;
}
context.meta_bitmap = &dscr3->efe;
}
/* TODO early check if meta_file has allocation extent redirections */
if (!udf_metadata_node_supported())
return EINVAL;
return 0;
}
/* ------------------------- VDS readin ------------------------- */
/* checks if the VDS information is correct and complete */
static int
udf_process_vds(void) {
union dscrptr *dscr;
union udf_pmap *mapping;
struct part_desc *pdesc;
struct long_ad fsd_loc;
uint8_t *pmap_pos;
char *domain_name, *map_name;
const char *check_name;
int pmap_stype, pmap_size;
int pmap_type, log_part, phys_part, raw_phys_part; //, maps_on;
int n_pm, n_phys, n_virt, n_spar, n_meta;
int len, error;
/* we need at least an anchor (trivial, but for safety) */
if (context.anchors[0] == NULL) {
pwarn("sanity check: no anchors?\n");
return EINVAL;
}
/* we need at least one primary and one logical volume descriptor */
if ((context.primary_vol == NULL) || (context.logical_vol) == NULL) {
pwarn("sanity check: missing primary or missing logical volume\n");
return EINVAL;
}
/* we need at least one partition descriptor */
if (context.partitions[0] == NULL) {
pwarn("sanity check: missing partition descriptor\n");
return EINVAL;
}
/* check logical volume sector size versus device sector size */
if (udf_rw32(context.logical_vol->lb_size) != context.sector_size) {
pwarn("sanity check: lb_size != sector size\n");
return EINVAL;
}
/* check domain name, should never fail */
domain_name = (char *) context.logical_vol->domain_id.id;
if (strncmp(domain_name, "*OSTA UDF Compliant", 20)) {
pwarn("sanity check: disc not OSTA UDF Compliant, aborting\n");
return EINVAL;
}
/* retrieve logical volume integrity sequence */
udf_retrieve_lvint();
/* check if we support this disc, ie less or equal to 0x250 */
if (udf_rw16(context.logvol_info->min_udf_writever) > 0x250) {
pwarn("implementation limit: minimum write version UDF 2.60 "
"and on are not supported\n");
return EINVAL;
}
/*
* check logvol mappings: effective virt->log partmap translation
* check and recording of the mapping results. Saves expensive
* strncmp() in tight places.
*/
n_pm = udf_rw32(context.logical_vol->n_pm); /* num partmaps */
pmap_pos = context.logical_vol->maps;
if (n_pm > UDF_PMAPS) {
pwarn("implementation limit: too many logvol mappings\n");
return EINVAL;
}
/* count types and set partition numbers */
context.data_part = context.metadata_part = context.fids_part = 0;
n_phys = n_virt = n_spar = n_meta = 0;
for (log_part = 0; log_part < n_pm; log_part++) {
mapping = (union udf_pmap *) pmap_pos;
pmap_stype = pmap_pos[0];
pmap_size = pmap_pos[1];
switch (pmap_stype) {
case 1: /* physical mapping */
/* volseq = udf_rw16(mapping->pm1.vol_seq_num); */
raw_phys_part = udf_rw16(mapping->pm1.part_num);
pmap_type = UDF_VTOP_TYPE_PHYS;
n_phys++;
context.data_part = log_part;
context.metadata_part = log_part;
context.fids_part = log_part;
break;
case 2: /* virtual/sparable/meta mapping */
map_name = (char *) mapping->pm2.part_id.id;
/* volseq = udf_rw16(mapping->pm2.vol_seq_num); */
raw_phys_part = udf_rw16(mapping->pm2.part_num);
pmap_type = UDF_VTOP_TYPE_UNKNOWN;
len = UDF_REGID_ID_SIZE;
check_name = "*UDF Virtual Partition";
if (strncmp(map_name, check_name, len) == 0) {
pmap_type = UDF_VTOP_TYPE_VIRT;
n_virt++;
context.metadata_part = log_part;
context.format_flags |= FORMAT_VAT;
break;
}
check_name = "*UDF Sparable Partition";
if (strncmp(map_name, check_name, len) == 0) {
pmap_type = UDF_VTOP_TYPE_SPAREABLE;
n_spar++;
layout.spareable_blockingnr = udf_rw16(mapping->pms.packet_len);
context.data_part = log_part;
context.metadata_part = log_part;
context.fids_part = log_part;
context.format_flags |= FORMAT_SPAREABLE;
break;
}
check_name = "*UDF Metadata Partition";
if (strncmp(map_name, check_name, len) == 0) {
pmap_type = UDF_VTOP_TYPE_META;
n_meta++;
layout.meta_file = udf_rw32(mapping->pmm.meta_file_lbn);
layout.meta_mirror = udf_rw32(mapping->pmm.meta_mirror_file_lbn);
layout.meta_bitmap = udf_rw32(mapping->pmm.meta_bitmap_file_lbn);
layout.meta_blockingnr = udf_rw32(mapping->pmm.alloc_unit_size);
layout.meta_alignment = udf_rw16(mapping->pmm.alignment_unit_size);
/* XXX metadata_flags in mapping->pmm.flags? XXX */
context.metadata_part = log_part;
context.fids_part = log_part;
context.format_flags |= FORMAT_META;
break;
}
break;
default:
return EINVAL;
}
/*
* BUGALERT: some rogue implementations use random physical
* partition numbers to break other implementations so lookup
* the number.
*/
phys_part = udf_find_raw_phys(raw_phys_part);
if (phys_part == UDF_PARTITIONS) {
pwarn("implementation limit: too many partitions\n");
return EINVAL;
}
if (pmap_type == UDF_VTOP_TYPE_UNKNOWN) {
pwarn("implementation limit: encountered unknown "
"logvol mapping `%s`!\n", map_name);
return EINVAL;
}
context.vtop [log_part] = phys_part;
context.vtop_tp[log_part] = pmap_type;
pmap_pos += pmap_size;
}
/* not winning the beauty contest */
context.vtop_tp[UDF_VTOP_RAWPART] = UDF_VTOP_TYPE_RAW;
/* test some basic UDF assertions/requirements */
if ((n_virt > 1) || (n_spar > 1) || (n_meta > 1)) {
pwarn("Sanity check: format error, more than one "
"virtual, sparable or meta mapping\n");
return EINVAL;
}
if (n_virt) {
if ((n_phys == 0) || n_spar || n_meta) {
pwarn("Sanity check: format error, no backing for "
"virtual partition\n");
return EINVAL;
}
}
if (n_spar + n_phys == 0) {
pwarn("Sanity check: can't combine a sparable and a "
"physical partition\n");
return EINVAL;
}
/* print format type as derived */
if (!preen) {
char bits[255];
snprintb(bits, sizeof(bits), FORMAT_FLAGBITS, context.format_flags);
printf("Format flags %s\n\n", bits);
}
/* read supporting tables */
pmap_pos = context.logical_vol->maps;
for (log_part = 0; log_part < n_pm; log_part++) {
mapping = (union udf_pmap *) pmap_pos;
pmap_size = pmap_pos[1];
switch (context.vtop_tp[log_part]) {
case UDF_VTOP_TYPE_PHYS :
/* nothing */
break;
case UDF_VTOP_TYPE_VIRT :
/* search and load VAT */
error = udf_search_vat(mapping, log_part);
if (error) {
pwarn("Couldn't find virtual allocation table\n");
return ENOENT;
}
break;
case UDF_VTOP_TYPE_SPAREABLE :
/* load one of the sparable tables */
error = udf_read_spareables(mapping, log_part);
if (error) {
pwarn("Couldn't load sparable blocks tables\n");
return ENOENT;
}
break;
case UDF_VTOP_TYPE_META :
/* load the associated file descriptors */
error = udf_read_metadata_nodes(mapping, log_part);
if (error) {
pwarn("Couldn't read in the metadata descriptors\n");
return ENOENT;
}
/*
* We have to extract the partition size from the meta
* data file length
*/
context.part_size[log_part] =
udf_rw64(context.meta_file->inf_len) / context.sector_size;
break;
default:
break;
}
pmap_pos += pmap_size;
}
/*
* Free/unallocated space bitmap readin delayed; the FS might be
* closed already; no need to read in copious amount of data only to
* not use it later.
*
* For now, extract partition sizes in our context
*/
for (int cnt = 0; cnt < UDF_PARTITIONS; cnt++) {
pdesc = context.partitions[cnt];
if (!pdesc)
continue;
context.part_size[cnt] = udf_rw32(pdesc->part_len);
context.part_unalloc_bits[cnt] = NULL;
}
/* read file set descriptor */
fsd_loc = context.logical_vol->lv_fsd_loc;
error = udf_read_dscr_virt(
udf_rw32(fsd_loc.loc.lb_num),
udf_rw16(fsd_loc.loc.part_num), &dscr);
if (error) {
pwarn("Couldn't read in file set descriptor\n");
pwarn("implementation limit: can't fix this\n");
return ENOENT;
}
if (udf_rw16(dscr->tag.id) != TAGID_FSD) {
pwarn("Expected fsd at (p %d, lb %d)\n",
udf_rw16(fsd_loc.loc.part_num),
udf_rw32(fsd_loc.loc.lb_num));
pwarn("File set descriptor not pointing to a file set!\n");
return ENOENT;
}
context.fileset_desc = &dscr->fsd;
/* signal its OK for now */
return 0;
}
#define UDF_UPDATE_DSCR(name, dscr) \
if (name) {\
free (name); \
updated = 1; \
} \
name = calloc(1, dscr_size); \
memcpy(name, dscr, dscr_size);
static void
udf_process_vds_descriptor(union dscrptr *dscr, int dscr_size) {
struct pri_vol_desc *pri;
struct logvol_desc *lvd;
uint16_t raw_phys_part, phys_part;
int updated = 0;
switch (udf_rw16(dscr->tag.id)) {
case TAGID_PRI_VOL : /* primary partition */
UDF_UPDATE_DSCR(context.primary_vol, dscr);
pri = context.primary_vol;
context.primary_name = malloc(32);
context.volset_name = malloc(128);
udf_to_unix_name(context.volset_name, 32, pri->volset_id, 32,
&pri->desc_charset);
udf_to_unix_name(context.primary_name, 128, pri->vol_id, 128,
&pri->desc_charset);
if (!preen && !updated) {
pwarn("Volume set `%s`\n", context.volset_name);
pwarn("Primary volume `%s`\n", context.primary_name);
}
break;
case TAGID_LOGVOL : /* logical volume */
UDF_UPDATE_DSCR(context.logical_vol, dscr);
/* could check lvd->domain_id */
lvd = context.logical_vol;
context.logvol_name = malloc(128);
udf_to_unix_name(context.logvol_name, 128, lvd->logvol_id, 128,
&lvd->desc_charset);
if (!preen && !updated)
pwarn("Logical volume `%s`\n", context.logvol_name);
break;
case TAGID_UNALLOC_SPACE : /* unallocated space */
UDF_UPDATE_DSCR(context.unallocated, dscr);
break;
case TAGID_IMP_VOL : /* implementation */
UDF_UPDATE_DSCR(context.implementation, dscr);
break;
case TAGID_PARTITION : /* partition(s) */
/* not much use if its not allocated */
if ((udf_rw16(dscr->pd.flags) & UDF_PART_FLAG_ALLOCATED) == 0) {
pwarn("Ignoring unallocated partition\n");
break;
}
raw_phys_part = udf_rw16(dscr->pd.part_num);
phys_part = udf_find_raw_phys(raw_phys_part);
if (phys_part >= UDF_PARTITIONS) {
pwarn("Too many physical partitions, ignoring\n");
break;
}
UDF_UPDATE_DSCR(context.partitions[phys_part], dscr);
break;
case TAGID_TERM : /* terminator */
break;
case TAGID_VOL : /* volume space ext */
pwarn("Ignoring VDS extender\n");
break;
default :
pwarn("Unknown VDS type %d found, ignored\n",
udf_rw16(dscr->tag.id));
}
}
static void
udf_read_vds_extent(union dscrptr *dscr, int vds_size) {
uint8_t *pos;
int sector_size = context.sector_size;
int dscr_size;
pos = (uint8_t *) dscr;
while (vds_size) {
/* process the descriptor */
dscr = (union dscrptr *) pos;
/* empty block terminates */
if (is_zero(dscr, sector_size))
return;
/* terminator terminates */
if (udf_rw16(dscr->tag.id) == TAGID_TERM)
return;
if (udf_check_tag(dscr))
pwarn("Bad descriptor sum in vds, ignoring\n");
dscr_size = udf_tagsize(dscr, sector_size);
if (udf_check_tag_payload(dscr, dscr_size))
pwarn("Bad descriptor CRC in vds, ignoring\n");
udf_process_vds_descriptor(dscr, dscr_size);
pos += dscr_size;
vds_size -= dscr_size;
}
}
static int
udf_copy_VDS_area(void *destbuf, void *srcbuf)
{
pwarn("TODO implement VDS copy area, signalling success\n");
return 0;
}
/* XXX why two buffers and not just read descritor by descriptor XXX */
static int
udf_check_VDS_areas(void) {
union dscrptr *vds1_buf, *vds2_buf;
int vds1_size, vds2_size;
int error, error1, error2;
vds1_size = layout.vds1_size * context.sector_size;
vds2_size = layout.vds2_size * context.sector_size;
vds1_buf = calloc(1, vds1_size);
vds2_buf = calloc(1, vds2_size);
assert(vds1_buf); assert(vds2_buf);
error1 = udf_read_phys(vds1_buf, layout.vds1, layout.vds1_size);
error2 = udf_read_phys(vds2_buf, layout.vds2, layout.vds2_size);
if (error1 && error2) {
pwarn("Can't read both volume descriptor areas!\n");
return -1;
}
if (!error1) {
/* retrieve data from VDS 1 */
udf_read_vds_extent(vds1_buf, vds1_size);
context.vds_buf = vds1_buf;
context.vds_size = vds1_size;
free(vds2_buf);
vds2_buf = NULL;
}
if (!error2) {
/* retrieve data from VDS 2 */
udf_read_vds_extent(vds2_buf, vds2_size);
context.vds_buf = vds2_buf;
context.vds_size = vds2_size;
free(vds1_buf);
vds1_buf = NULL;
}
/* check if all is correct and complete */
error = udf_process_vds();
if (error)
return error;
/* TODO check if both area's are logically the same */
error = 0;
if (!error1 && error2) {
/* first OK, second faulty */
pwarn("Backup volume descriptor missing or damaged\n");
if (context.format_flags & FORMAT_SEQUENTIAL) {
pwarn("Can't fixup backup volume descriptor on "
"SEQUENTIAL media\n");
} else if (ask(1, "Fixup backup volume descriptor")) {
error = udf_copy_VDS_area(vds2_buf, vds1_buf);
pwarn("\n");
}
}
if (error1 && !error2) {
/* second OK, first faulty */
pwarn("Primary volume descriptor missing or damaged\n");
if (context.format_flags & FORMAT_SEQUENTIAL) {
pwarn("Can't fix up primary volume descriptor on "
"SEQUENTIAL media\n");
} else if (ask(1, "Fix up primary volume descriptor")) {
error = udf_copy_VDS_area(vds1_buf, vds2_buf);
}
}
if (error)
pwarn("copying VDS areas failed!\n");
if (!preen)
printf("\n");
return error;
}
/* --------------------------------------------------------------------- */
static int
udf_prepare_writing(void)
{
union dscrptr *zero_dscr, *dscr;
struct mmc_trackinfo ti;
uint32_t first_lba, loc;
int sector_size = context.sector_size;
int error;
error = udf_prepare_disc();
if (error) {
pwarn("*** Preparing disc for writing failed!\n");
return error;
}
/* if we are not on sequential media, we're done */
if ((context.format_flags & FORMAT_VAT) == 0)
return 0;
/* if the disc is full, we drop back to read only */
if (mmc_discinfo.disc_state == MMC_STATE_FULL)
rdonly = 1;
if (rdonly)
return 0;
/* check if we need to open the last track */
ti.tracknr = mmc_discinfo.last_track_last_session;
error = udf_update_trackinfo(&ti);
if (error)
return error;
if (!(ti.flags & MMC_TRACKINFO_BLANK) &&
(ti.flags & MMC_TRACKINFO_NWA_VALID)) {
/*
* Not closed; translate next_writable to a position relative to our
* backing partition
*/
context.alloc_pos[context.data_part] = ti.next_writable -
udf_rw32(context.partitions[context.data_part]->start_loc);
wrtrack_skew = ti.next_writable % layout.blockingnr;
return 0;
}
assert(ti.flags & MMC_TRACKINFO_NWA_VALID);
/* just in case */
udf_suspend_writing();
/* 'add' a new track */
udf_update_discinfo();
memset(&context.last_ti, 0, sizeof(struct mmc_trackinfo));
context.last_ti.tracknr = mmc_discinfo.first_track_last_session;
(void) udf_update_trackinfo(&context.last_ti);
assert(mmc_discinfo.last_session_state == MMC_STATE_EMPTY);
first_lba = context.last_ti.track_start;
wrtrack_skew = context.last_ti.track_start % layout.blockingnr;
/*
* location of iso9660 vrs is defined as first sector AFTER 32kb,
* minimum `sector size' 2048
*/
layout.iso9660_vrs = ((32*1024 + sector_size - 1) / sector_size)
+ first_lba;
/* anchor starts at specified offset in sectors */
layout.anchors[0] = first_lba + 256;
/* ready for appending, write preamble, we are using overwrite here! */
if ((zero_dscr = calloc(1, context.sector_size)) == NULL)
return ENOMEM;
loc = first_lba;
for (; loc < first_lba + 256; loc++) {
if ((error = udf_write_sector(zero_dscr, loc))) {
free(zero_dscr);
return error;
}
}
free(zero_dscr);
/* write new ISO9660 volume recognition sequence */
if ((error = udf_write_iso9660_vrs())) {
pwarn("internal error: can't write iso966 VRS in new session!\n");
rdonly = 1;
return error;
}
/* write out our old anchor, VDS spaces will be reused */
assert(context.anchors[0]);
dscr = (union dscrptr *) context.anchors[0];
loc = layout.anchors[0];
if ((error = udf_write_dscr_phys(dscr, loc, 1))) {
pwarn("internal error: can't write anchor in new session!\n");
rdonly = 1;
return error;
}
context.alloc_pos[context.data_part] = first_lba + 257 -
udf_rw32(context.partitions[context.data_part]->start_loc);
return 0;
}
static int
udf_close_volume_vat(void)
{
int integrity_type;
/* only write out when its open */
integrity_type = udf_rw32(context.logvol_integrity->integrity_type);
if (integrity_type == UDF_INTEGRITY_CLOSED)
return 0;
if (!preen)
printf("\n");
if (!ask(1, "Write out modifications"))
return 0;
/* writeout our VAT contents */
udf_allow_writing();
return udf_writeout_VAT();
}
static int
udf_close_volume(void)
{
struct part_desc *part;
struct part_hdr_desc *phd;
struct logvol_int_desc *lvid;
struct udf_logvol_info *lvinfo;
struct logvol_desc *logvol;
uint32_t bitmap_len, bitmap_lb, bitmap_numlb;
int i, equal, error;
lvid = context.logvol_integrity;
logvol = context.logical_vol;
lvinfo = context.logvol_info;
assert(lvid);
assert(logvol);
assert(lvinfo);
/* check our highest unique id */
if (context.unique_id > udf_rw64(lvid->lvint_next_unique_id)) {
pwarn("Last unique id updated from %" PRIi64 " to %" PRIi64 " : FIXED\n",
udf_rw64(lvid->lvint_next_unique_id),
context.unique_id);
open_integrity = 1;
}
/* check file/directory counts */
if (context.num_files != udf_rw32(lvinfo->num_files)) {
pwarn("Number of files corrected from %d to %d : FIXED\n",
udf_rw32(lvinfo->num_files),
context.num_files);
open_integrity = 1;
}
if (context.num_directories != udf_rw32(lvinfo->num_directories)) {
pwarn("Number of directories corrected from %d to %d : FIXED\n",
udf_rw32(lvinfo->num_directories),
context.num_directories);
open_integrity = 1;
}
if (vat_writeout)
open_integrity = 1;
if (open_integrity)
udf_update_lvintd(UDF_INTEGRITY_OPEN);
if (context.format_flags & FORMAT_VAT)
return udf_close_volume_vat();
/* adjust free space accounting! */
for (i = 0; i < UDF_PARTITIONS; i++) {
part = context.partitions[i];
if (!part)
continue;
phd = &part->pd_part_hdr;
bitmap_len = udf_rw32(phd->unalloc_space_bitmap.len);
bitmap_lb = udf_rw32(phd->unalloc_space_bitmap.lb_num);
if (bitmap_len == 0) {
error = 0;
continue;
}
equal = memcmp( recorded_part_unalloc_bits[i],
context.part_unalloc_bits[i],
bitmap_len) == 0;
if (!equal || (context.part_free[i] != recorded_part_free[i])) {
if (!equal)
pwarn("Calculated bitmap for partition %d not equal "
"to recorded one : FIXED\n", i);
pwarn("Free space on partition %d corrected "
"from %d to %d blocks : FIXED\n", i,
recorded_part_free[i],
context.part_free[i]);
/* write out updated free space map */
pwarn("Updating unallocated bitmap for partition\n");
if (!preen)
printf("Writing free space map "
"for partition %d\n", i);
error = 0;
if (context.vtop_tp[i] == UDF_VTOP_TYPE_META) {
if (context.meta_bitmap) {
assert(i == context.metadata_part);
error = udf_process_file(
(union dscrptr *) context.meta_bitmap,
context.data_part,
(uint8_t **) &(context.part_unalloc_bits[i]),
AD_SAVE_FILE, NULL);
}
} else {
bitmap_numlb = udf_bytes_to_sectors(bitmap_len);
error = udf_write_dscr_virt(
(union dscrptr *) context.part_unalloc_bits[i],
bitmap_lb,
i,
bitmap_numlb);
}
if (error)
pwarn("Updating unallocated bitmap failed, "
"continuing\n");
udf_update_lvintd(UDF_INTEGRITY_OPEN);
}
}
/* write out the logical volume integrity sequence */
error = udf_writeout_lvint();
return error;
}
/* --------------------------------------------------------------------- */
/*
* Main part of file system checking.
*
* Walk the entire directory tree and check all link counts and rebuild the
* free space map (if present) on the go.
*/
static struct udf_fsck_node *
udf_new_fsck_node(struct udf_fsck_node *parent, struct long_ad *loc, char *fname)
{
struct udf_fsck_node *this;
this = calloc(1, sizeof(struct udf_fsck_node));
if (!this)
return NULL;
this->parent = parent;
this->fname = strdup(fname);
this->loc = *loc;
this->fsck_flags = 0;
this->link_count = 0;
this->found_link_count = 0;
return this;
}
static void
udf_node_path_piece(char *pathname, struct udf_fsck_node *node)
{
if (node->parent) {
udf_node_path_piece(pathname, node->parent);
if (node->fsck_flags & FSCK_NODE_FLAG_STREAM_DIR)
strcat(pathname, "");
else
strcat(pathname, "/");
}
strcat(pathname, node->fname);
}
static char *
udf_node_path(struct udf_fsck_node *node)
{
static char pathname[MAXPATHLEN + 10];
strcpy(pathname, "`");
if (node->parent)
udf_node_path_piece(pathname, node);
else
strcat(pathname, "/");
strcat(pathname, "'");
return pathname;
}
static void
udf_recursive_keep(struct udf_fsck_node *node)
{
while (node->parent) {
node = node->parent;
node->fsck_flags |= FSCK_NODE_FLAG_KEEP;
}
}
static int
udf_quick_check_fids(struct udf_fsck_node *node, union dscrptr *dscr)
{
struct udf_fsck_fid_context fid_context;
int error;
fid_context.fid_offset = 0;
fid_context.data_left = node->found.inf_len;
error = udf_process_file(dscr, context.fids_part,
&node->directory,
AD_CHECK_FIDS,
&fid_context);
return error;
}
/* read descriptor at node's location */
static int
udf_read_node_dscr(struct udf_fsck_node *node, union dscrptr **dscrptr)
{
*dscrptr = NULL;
return udf_read_dscr_virt(
udf_rw32(node->loc.loc.lb_num),
udf_rw16(node->loc.loc.part_num),
dscrptr);
}
static int
udf_extract_node_info(struct udf_fsck_node *node, union dscrptr *dscr,
int be_quiet)
{
struct icb_tag *icb = NULL;
struct file_entry *fe = NULL;
struct extfile_entry *efe = NULL;
int ad_type, error;
if (udf_rw16(dscr->tag.id) == TAGID_FENTRY) {
fe = (struct file_entry *) dscr;
icb = &fe->icbtag;
node->declared.inf_len = udf_rw64(fe->inf_len);
node->declared.obj_size = udf_rw64(fe->inf_len);
node->declared.logblks_rec = udf_rw64(fe->logblks_rec);
node->link_count = udf_rw16(fe->link_cnt);
node->unique_id = udf_rw64(fe->unique_id);
/* XXX FAULT INJECTION POINT XXX */
//if (fe->unique_id == 33) { return ENOENT;}
}
if (udf_rw16(dscr->tag.id) == TAGID_EXTFENTRY) {
efe = (struct extfile_entry *) dscr;
icb = &efe->icbtag;
node->declared.inf_len = udf_rw64(efe->inf_len);
node->declared.obj_size = udf_rw64(efe->obj_size);
node->declared.logblks_rec = udf_rw64(efe->logblks_rec);
node->link_count = udf_rw16(efe->link_cnt);
node->unique_id = udf_rw64(efe->unique_id);
node->streamdir_loc = efe->streamdir_icb;
if (node->streamdir_loc.len)
node->fsck_flags |= FSCK_NODE_FLAG_HAS_STREAM_DIR;
/* XXX FAULT INJECTION POINT XXX */
//if (efe->unique_id == 0x891) { return ENOENT;}
}
if (!fe && !efe) {
//printf("NOT REFERENCING AN FE/EFE!\n");
return ENOENT;
}
if (node->unique_id >= context.unique_id)
context.unique_id = node->unique_id+1;
ad_type = udf_rw16(icb->flags) & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
if ((ad_type != UDF_ICB_INTERN_ALLOC) &&
(ad_type != UDF_ICB_SHORT_ALLOC) &&
(ad_type != UDF_ICB_LONG_ALLOC)) {
pwarn("%s : unknown allocation type\n",
udf_node_path(node));
return EINVAL;
}
bzero(&node->found, sizeof(node->found));
error = udf_process_file(dscr, udf_rw16(node->loc.loc.part_num), NULL,
AD_GATHER_STATS, (void *) &node->found);
switch (icb->file_type) {
case UDF_ICB_FILETYPE_RANDOMACCESS :
case UDF_ICB_FILETYPE_BLOCKDEVICE :
case UDF_ICB_FILETYPE_CHARDEVICE :
case UDF_ICB_FILETYPE_FIFO :
case UDF_ICB_FILETYPE_SOCKET :
case UDF_ICB_FILETYPE_SYMLINK :
case UDF_ICB_FILETYPE_REALTIME :
break;
default:
/* unknown or unsupported file type, TODO clearing? */
free(dscr);
pwarn("%s : specification violation, unknown file type %d\n",
udf_node_path(node), icb->file_type);
return ENOENT;
case UDF_ICB_FILETYPE_STREAMDIR :
case UDF_ICB_FILETYPE_DIRECTORY :
/* read in the directory contents */
error = udf_readin_file(dscr, udf_rw16(node->loc.loc.part_num),
&node->directory, NULL);
/* XXX FAULT INJECTION POINT XXX */
//if (dscr->efe.unique_id == 109) node->directory[125] = 0xff;
//if (dscr->efe.unique_id == 310) memset(node->directory+1024, 0, 300);
if (error && !be_quiet) {
pwarn("%s : directory has read errors\n",
udf_node_path(node));
if (ask(0, "Directory could be fixed or cleared. "
"Wipe defective directory")) {
return ENOENT;
}
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
node->fsck_flags |= FSCK_NODE_FLAG_DIRECTORY;
error = udf_quick_check_fids(node, dscr);
if (error) {
if (!(node->fsck_flags & FSCK_NODE_FLAG_REPAIRDIR))
pwarn("%s : directory file entries need repair\n",
udf_node_path(node));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
}
/* XXX FAULT INJECTION POINT XXX */
//if (fe->unique_id == 0) node->link_count++;
//if (efe->unique_id == 0) node->link_count++;
//if (efe->unique_id == 772) { node->declared.inf_len += 205; node->declared.obj_size -= 0; }
return 0;
}
static void
udf_fixup_lengths_pass1(struct udf_fsck_node *node, union dscrptr *dscr)
{
int64_t diff;
/* file length check */
diff = node->found.inf_len - node->declared.inf_len;
if (diff) {
pwarn("%s : recorded information length incorrect: "
"%" PRIu64 " instead of declared %" PRIu64 "\n",
udf_node_path(node),
node->found.inf_len, node->declared.inf_len);
node->declared.inf_len = node->found.inf_len;
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
}
/* recorded logical blocks count check */
diff = node->found.logblks_rec - node->declared.logblks_rec;
if (diff) {
pwarn("%s : logical blocks recorded incorrect: "
"%" PRIu64 " instead of declared %" PRIu64 ", fixing\n",
udf_node_path(node),
node->found.logblks_rec, node->declared.logblks_rec);
node->declared.logblks_rec = node->found.logblks_rec;
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
}
/* tally object sizes for streamdirs */
node->found.obj_size = node->found.inf_len;
if (node->fsck_flags & FSCK_NODE_FLAG_STREAM_ENTRY) {
assert(node->parent); /* streamdir itself */
if (node->parent->parent)
node->parent->parent->found.obj_size +=
node->found.inf_len;
}
/* check descriptor CRC length */
if (udf_rw16(dscr->tag.desc_crc_len) !=
udf_tagsize(dscr, 1) - sizeof(struct desc_tag)) {
pwarn("%s : node file descriptor CRC length mismatch; "
"%d declared, %zu\n",
udf_node_path(node), udf_rw16(dscr->tag.desc_crc_len),
udf_tagsize(dscr, 1) - sizeof(struct desc_tag));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
}
}
static void
udf_node_pass1_add_entry(struct udf_fsck_node *node,
struct fileid_desc *fid, struct dirent *dirent)
{
struct udf_fsck_node *leaf_node;
int entry;
/* skip deleted FID entries */
if (fid->file_char & UDF_FILE_CHAR_DEL)
return;
if (udf_rw32(fid->icb.loc.lb_num) == 0) {
pwarn("%s : FileID entry `%s` has invalid location\n",
udf_node_path(node), dirent->d_name);
udf_recursive_keep(node);
if (node->parent)
node->parent->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
return;
}
/* increase parent link count */
if (fid->file_char & UDF_FILE_CHAR_PAR) {
if (node->parent)
node->parent->found_link_count++;
return;
}
/* lookup if we already know this node */
leaf_node = udf_node_lookup(&fid->icb);
if (leaf_node) {
/* got a hard link! */
leaf_node->found_link_count++;
return;
}
/* create new node */
leaf_node = udf_new_fsck_node(
node, &fid->icb, dirent->d_name);
if (node->fsck_flags & FSCK_NODE_FLAG_STREAM_DIR)
leaf_node->fsck_flags |= FSCK_NODE_FLAG_STREAM_ENTRY;
TAILQ_INSERT_TAIL(&fs_nodes, leaf_node, next);
entry = udf_calc_node_hash(&fid->icb);
LIST_INSERT_HEAD(&fs_nodes_hash[entry], leaf_node, next_hash);
}
static void
udf_node_pass1_add_streamdir_entry(struct udf_fsck_node *node)
{
struct udf_fsck_node *leaf_node;
int entry;
/* check for recursion */
if (node->fsck_flags & FSCK_NODE_FLAG_STREAM) {
/* recursive streams are not allowed by spec */
pwarn("%s : specification violation, recursive stream dir\n",
udf_node_path(node));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_WIPE_STREAM_DIR;
return;
}
/* lookup if we already know this node */
leaf_node = udf_node_lookup(&node->streamdir_loc);
if (leaf_node) {
pwarn("%s : specification violation, hardlinked streamdir\n",
udf_node_path(leaf_node));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_WIPE_STREAM_DIR;
return;
}
/* create new node */
leaf_node = udf_new_fsck_node(
node, &node->streamdir_loc, strdup(""));
leaf_node->fsck_flags |= FSCK_NODE_FLAG_STREAM_DIR;
/* streamdirs have link count 0 : ECMA 4/14.9.6 */
leaf_node->found_link_count--;
/* insert in to lists */
TAILQ_INSERT_TAIL(&fs_nodes, leaf_node, next);
entry = udf_calc_node_hash(&node->streamdir_loc);
LIST_INSERT_HEAD(&fs_nodes_hash[entry], leaf_node, next_hash);
}
static int
udf_process_node_pass1(struct udf_fsck_node *node, union dscrptr *dscr)
{
struct fileid_desc *fid;
struct dirent dirent;
struct charspec osta_charspec;
int64_t fpos, new_length, rest_len;
uint32_t fid_len;
uint8_t *bpos;
int isdir;
int error;
isdir = node->fsck_flags & FSCK_NODE_FLAG_DIRECTORY;
/* keep link count */
node->found_link_count++;
if (isdir) {
assert(node->directory);
udf_rebuild_fid_stream(node, &new_length);
node->found.inf_len = new_length;
rest_len = new_length;
}
udf_fixup_lengths_pass1(node, dscr);
/* check UniqueID */
if (node->parent) {
if (node->fsck_flags & FSCK_NODE_FLAG_STREAM) {
/* XXX FAULT INJECTION POINT XXX */
//node->unique_id = 0xdeadbeefcafe;
if (node->unique_id != node->parent->unique_id) {
pwarn("%s : stream file/dir UniqueID mismatch "
"with parent\n",
udf_node_path(node));
/* do the work here prematurely for our siblings */
udf_recursive_keep(node);
node->unique_id = node->parent->unique_id;
node->fsck_flags |= FSCK_NODE_FLAG_COPY_PARENT_ID |
FSCK_NODE_FLAG_DIRTY;
assert(node->parent);
node->parent->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
} else if (node->unique_id < 16) {
pwarn("%s : file has bad UniqueID\n",
udf_node_path(node));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_NEW_UNIQUE_ID;
assert(node->parent);
node->parent->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
} else {
/* rootdir */
if (node->unique_id != 0) {
pwarn("%s : has bad UniqueID, has to be zero\n",
udf_node_path(node));
udf_recursive_keep(node);
node->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
}
/* add streamdir if present */
if (node->fsck_flags & FSCK_NODE_FLAG_HAS_STREAM_DIR)
udf_node_pass1_add_streamdir_entry(node);
/* add all children */
if (isdir) {
node->fsck_flags |= FSCK_NODE_FLAG_PAR_NOT_FOUND;
rest_len = node->found.inf_len;
/* walk through all our FIDs in the directory stream */
bpos = node->directory;
fpos = 0;
while (rest_len > 0) {
fid = (struct fileid_desc *) bpos;
fid_len = udf_fidsize(fid);
/* get printable name */
memset(&dirent, 0, sizeof(dirent));
udf_osta_charset(&osta_charspec);
udf_to_unix_name(dirent.d_name, NAME_MAX,
(char *) fid->data + udf_rw16(fid->l_iu), fid->l_fi,
&osta_charspec);
dirent.d_namlen = strlen(dirent.d_name);
/* '..' has no name, so provide one */
if (fid->file_char & UDF_FILE_CHAR_PAR) {
strcpy(dirent.d_name, "..");
node->fsck_flags &= ~FSCK_NODE_FLAG_PAR_NOT_FOUND;
}
udf_node_pass1_add_entry(node, fid, &dirent);
fpos += fid_len;
bpos += fid_len;
rest_len -= fid_len;
}
}
error = udf_process_file(dscr, udf_rw16(node->loc.loc.part_num), NULL,
AD_CHECK_USED, node);
if (error) {
pwarn("%s : internal error: checking for being allocated shouldn't fail\n",
udf_node_path(node));
return EINVAL;
}
/* file/directory is OK and referenced as its size won't change */
error = udf_process_file(dscr, udf_rw16(node->loc.loc.part_num), NULL,
AD_MARK_AS_USED, NULL);
if (error) {
pwarn("%s : internal error: marking allocated shouldn't fail\n",
udf_node_path(node));
return EINVAL;
}
(void) fpos;
return 0;
}
static void
udf_node_pass3_repairdir(struct udf_fsck_node *node, union dscrptr *dscr)
{
struct fileid_desc *fid, *last_empty_fid;
struct udf_fsck_node *file_node;
struct udf_fsck_fid_context fid_context;
struct dirent dirent;
struct charspec osta_charspec;
int64_t fpos, rest_len;
uint32_t fid_len;
uint8_t *bpos;
int parent_missing;
int error;
pwarn("%s : fixing up directory\n", udf_node_path(node));
assert(node->fsck_flags & FSCK_NODE_FLAG_DIRECTORY);
rest_len = node->found.inf_len;
udf_osta_charset(&osta_charspec);
bpos = node->directory;
fpos = 0;
parent_missing = (node->fsck_flags & FSCK_NODE_FLAG_PAR_NOT_FOUND)? 1:0;
last_empty_fid = NULL;
while (rest_len > 0) {
fid = (struct fileid_desc *) bpos;
fid_len = udf_fidsize(fid);
/* get printable name */
memset(&dirent, 0, sizeof(dirent));
udf_to_unix_name(dirent.d_name, NAME_MAX,
(char *) fid->data + udf_rw16(fid->l_iu), fid->l_fi,
&osta_charspec);
dirent.d_namlen = strlen(dirent.d_name);
/* '..' has no name, so provide one */
if (fid->file_char & UDF_FILE_CHAR_PAR) {
strcpy(dirent.d_name, "..");
}
/* only look up when not deleted */
file_node = NULL;
if ((fid->file_char & UDF_FILE_CHAR_DEL) == 0)
file_node = udf_node_lookup(&fid->icb);
/* if found */
if (file_node) {
/* delete files which couldn't be found */
if (file_node && (file_node->fsck_flags & FSCK_NODE_FLAG_NOTFOUND)) {
fid->file_char |= UDF_FILE_CHAR_DEL;
memset(&fid->icb, 0, sizeof(struct long_ad));
}
/* fix up FID UniqueID errors */
if (fid->icb.longad_uniqueid != file_node->unique_id)
fid->icb.longad_uniqueid = udf_rw64(file_node->unique_id);
} else {
/* just mark it deleted if not found */
fid->file_char |= UDF_FILE_CHAR_DEL;
}
if (fid->file_char & UDF_FILE_CHAR_DEL) {
memset(&fid->icb, 0 , sizeof(struct long_ad));
if (context.dscrver == 2) {
uint8_t *cpos;
/* compression IDs are preserved */
cpos = (fid->data + udf_rw16(fid->l_iu));
if (*cpos == 254)
*cpos = 8;
if (*cpos == 255)
*cpos = 16;
}
}
fpos += fid_len;
bpos += fid_len;
rest_len -= fid_len;
assert(rest_len >= 0);
}
if (parent_missing) {
/* this should be valid or we're in LALA land */
assert(last_empty_fid);
pwarn("%s : implementation limit, can't fix up missing parent node yet!\n",
udf_node_path(node));
}
node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
fid_context.fid_offset = 0;
fid_context.data_left = node->found.inf_len;
error = udf_process_file(dscr, context.fids_part,
&node->directory,
AD_ADJUST_FIDS | AD_SAVE_FILE,
&fid_context);
if (error)
pwarn("Failed to write out directory!\n");
(void) fpos;
}
static void
udf_node_pass3_writeout_update(struct udf_fsck_node *node, union dscrptr *dscr)
{
struct file_entry *fe = NULL;
struct extfile_entry *efe = NULL;
int crc_len, error;
vat_writeout = 1;
if (udf_rw16(dscr->tag.id) == TAGID_FENTRY) {
fe = (struct file_entry *) dscr;
fe->inf_len = udf_rw64(node->declared.inf_len);
fe->logblks_rec = udf_rw64(node->declared.logblks_rec);
fe->link_cnt = udf_rw16(node->link_count);
fe->unique_id = udf_rw64(node->unique_id);
}
if (udf_rw16(dscr->tag.id) == TAGID_EXTFENTRY) {
efe = (struct extfile_entry *) dscr;
efe->inf_len = udf_rw64(node->declared.inf_len);
efe->obj_size = udf_rw64(node->declared.obj_size);
efe->logblks_rec = udf_rw64(node->declared.logblks_rec);
efe->link_cnt = udf_rw16(node->link_count);
efe->unique_id = udf_rw64(node->unique_id);
/* streamdir directly cleared in dscr */
}
/* fixup CRC length (if needed) */
crc_len = udf_tagsize(dscr, 1) - sizeof(struct desc_tag);
dscr->tag.desc_crc_len = udf_rw16(crc_len);
pwarn("%s : updating node\n", udf_node_path(node));
error = udf_write_dscr_virt(dscr, udf_rw32(node->loc.loc.lb_num),
udf_rw16(node->loc.loc.part_num), 1);
udf_shadow_VAT_in_use(&node->loc);
if (error)
pwarn("%s failed\n", __func__);
}
static void
udf_create_new_space_bitmaps_and_reset_freespace(void)
{
struct space_bitmap_desc *sbd, *new_sbd;
struct part_desc *part;
struct part_hdr_desc *phd;
uint32_t bitmap_len, bitmap_lb, bitmap_numlb;
uint32_t cnt;
int i, p, dscr_size;
int error;
/* copy recorded freespace info and clear counters */
for (i = 0; i < UDF_PARTITIONS; i++) {
recorded_part_free[i] = context.part_free[i];
context.part_free[i] = context.part_size[i];
}
/* clone existing bitmaps */
for (i = 0; i < UDF_PARTITIONS; i++) {
sbd = context.part_unalloc_bits[i];
recorded_part_unalloc_bits[i] = sbd;
if (sbd == NULL)
continue;
dscr_size = udf_tagsize((union dscrptr *) sbd,
context.sector_size);
new_sbd = calloc(1, dscr_size);
memcpy(new_sbd, sbd, sizeof(struct space_bitmap_desc)-1);
/* fill space with 0xff to indicate free */
for (cnt = 0; cnt < udf_rw32(sbd->num_bytes); cnt++)
new_sbd->data[cnt] = 0xff;
context.part_unalloc_bits[i] = new_sbd;
}
/* allocate the space bitmaps themselves (normally one) */
for (i = 0; i < UDF_PARTITIONS; i++) {
part = context.partitions[i];
if (!part)
continue;
phd = &part->pd_part_hdr;
bitmap_len = udf_rw32(phd->unalloc_space_bitmap.len);
bitmap_lb = udf_rw32(phd->unalloc_space_bitmap.lb_num);
if (bitmap_len == 0)
continue;
bitmap_numlb = udf_bytes_to_sectors(bitmap_len);
sbd = context.part_unalloc_bits[i];
assert(sbd);
udf_mark_allocated(bitmap_lb, context.vtop[i], bitmap_numlb);
}
/* special case for metadata partition */
if (context.format_flags & FORMAT_META) {
i = context.metadata_part;
p = context.vtop[i];
assert(context.vtop_tp[i] == UDF_VTOP_TYPE_META);
error = udf_process_file((union dscrptr *) context.meta_file,
p, NULL, AD_MARK_AS_USED, NULL);
error = udf_process_file((union dscrptr *) context.meta_mirror,
p, NULL, AD_MARK_AS_USED, NULL);
if (context.meta_bitmap) {
error = udf_process_file(
(union dscrptr *) context.meta_bitmap,
p, NULL, AD_MARK_AS_USED, NULL);
assert(error == 0);
}
}
/* mark fsd allocation ! */
udf_mark_allocated(udf_rw32(context.fileset_desc->tag.tag_loc),
context.metadata_part, 1);
}
static void
udf_shadow_VAT_in_use(struct long_ad *loc)
{
uint32_t i;
uint8_t *vat_pos, *shadow_vat_pos;
if (context.vtop_tp[context.metadata_part] != UDF_VTOP_TYPE_VIRT)
return;
i = udf_rw32(loc->loc.lb_num);
vat_pos = context.vat_contents + context.vat_start + i*4;
shadow_vat_pos = shadow_vat_contents + context.vat_start + i*4;
/* keeping endian */
*(uint32_t *) shadow_vat_pos = *(uint32_t *) vat_pos;
}
static void
udf_create_shadow_VAT(void)
{
struct long_ad fsd_loc;
uint32_t vat_entries, i;
uint8_t *vat_pos;
if (context.vtop_tp[context.metadata_part] != UDF_VTOP_TYPE_VIRT)
return;
shadow_vat_contents = calloc(1, context.vat_allocated);
assert(shadow_vat_contents);
memcpy(shadow_vat_contents, context.vat_contents, context.vat_size);
vat_entries = (context.vat_size - context.vat_start)/4;
for (i = 0; i < vat_entries; i++) {
vat_pos = shadow_vat_contents + context.vat_start + i*4;
*(uint32_t *) vat_pos = udf_rw32(0xffffffff);
}
/*
* Record our FSD in this shadow VAT since its the only one outside
* the nodes.
*/
memset(&fsd_loc, 0, sizeof(struct long_ad));
fsd_loc.loc.lb_num = context.fileset_desc->tag.tag_loc;
udf_shadow_VAT_in_use(&fsd_loc);
}
static void
udf_check_shadow_VAT(void)
{
uint32_t vat_entries, i;
uint8_t *vat_pos, *shadow_vat_pos;
int difference = 0;
if (context.vtop_tp[context.metadata_part] != UDF_VTOP_TYPE_VIRT)
return;
vat_entries = (context.vat_size - context.vat_start)/4;
for (i = 0; i < vat_entries; i++) {
vat_pos = context.vat_contents + context.vat_start + i*4;
shadow_vat_pos = shadow_vat_contents + context.vat_start + i*4;
if (*(uint32_t *) vat_pos != *(uint32_t *) shadow_vat_pos) {
difference++;
}
}
memcpy(context.vat_contents, shadow_vat_contents, context.vat_size);
if (difference) {
if (!preen)
printf("\t\t");
pwarn("%d unused VAT entries cleaned\n", difference);
vat_writeout = 1;
}
}
static int
udf_check_directory_tree(void)
{
union dscrptr *dscr;
struct udf_fsck_node *root_node, *sys_stream_node;
struct udf_fsck_node *cur_node, *next_node;
struct long_ad root_icb, sys_stream_icb;
bool dont_repair;
int entry, error;
assert(TAILQ_EMPTY(&fs_nodes));
/* (re)init queues and hash lists */
TAILQ_INIT(&fs_nodes);
TAILQ_INIT(&fsck_overlaps);
for (int i = 0; i < HASH_HASHSIZE; i++)
LIST_INIT(&fs_nodes_hash[i]);
/* create a new empty copy of the space bitmaps */
udf_create_new_space_bitmaps_and_reset_freespace();
udf_create_shadow_VAT();
/* start from the root */
root_icb = context.fileset_desc->rootdir_icb;
sys_stream_icb = context.fileset_desc->streamdir_icb;
root_node = udf_new_fsck_node(NULL, &root_icb, strdup(""));
assert(root_node);
TAILQ_INSERT_TAIL(&fs_nodes, root_node, next);
entry = udf_calc_node_hash(&root_node->loc);
LIST_INSERT_HEAD(&fs_nodes_hash[entry], root_node, next_hash);
sys_stream_node = NULL;
if (sys_stream_icb.len) {
sys_stream_node = udf_new_fsck_node(NULL, &sys_stream_icb, strdup("#"));
assert(sys_stream_node);
sys_stream_node->fsck_flags |= FSCK_NODE_FLAG_STREAM_DIR;
TAILQ_INSERT_TAIL(&fs_nodes, sys_stream_node, next);
entry = udf_calc_node_hash(&sys_stream_node->loc);
LIST_INSERT_HEAD(&fs_nodes_hash[entry], sys_stream_node, next_hash);
}
/* pass 1 */
if (!preen)
printf("\tPass 1, reading in directory trees\n");
context.unique_id = MAX(0x10, context.unique_id);
TAILQ_FOREACH(cur_node, &fs_nodes, next) {
/* read in node */
error = udf_read_node_dscr(cur_node, &dscr);
if (!error)
error = udf_extract_node_info(cur_node, dscr, 0);
if (error) {
pwarn("%s : invalid reference or bad descriptor, DELETING\n",
udf_node_path(cur_node));
udf_recursive_keep(cur_node);
cur_node->fsck_flags |= FSCK_NODE_FLAG_NOTFOUND;
if (cur_node->parent) {
if (cur_node->fsck_flags & FSCK_NODE_FLAG_STREAM_DIR)
cur_node->parent->fsck_flags |=
FSCK_NODE_FLAG_WIPE_STREAM_DIR;
else
cur_node->parent->fsck_flags |=
FSCK_NODE_FLAG_REPAIRDIR;
;
}
free(dscr);
continue;
}
if (print_info) {
pwarn("Processing %s\n", udf_node_path(cur_node));
print_info = 0;
}
/* directory found in stream directory? */
if (cur_node->parent &&
(cur_node->parent->fsck_flags & FSCK_NODE_FLAG_STREAM_DIR) &&
(cur_node->fsck_flags & FSCK_NODE_FLAG_DIRECTORY))
{
pwarn("%s : specification violation, directory in stream directory\n",
udf_node_path(cur_node));
if (ask(0, "Clear directory")) {
udf_recursive_keep(cur_node);
cur_node->fsck_flags |= FSCK_NODE_FLAG_NOTFOUND;
cur_node->parent->fsck_flags |=
FSCK_NODE_FLAG_REPAIRDIR;
continue;
}
}
error = udf_process_node_pass1(cur_node, dscr);
free(dscr);
if (error)
return error;
}
/* pass 1b, if there is overlap, find matching pairs */
dont_repair = false;
if (!TAILQ_EMPTY(&fsck_overlaps)) {
struct udf_fsck_overlap *overlap;
dont_repair = true;
pwarn("*** Overlaps detected! rescanning tree for matching pairs ***\n");
TAILQ_FOREACH(cur_node, &fs_nodes, next) {
if (cur_node->fsck_flags & FSCK_NODE_FLAG_NOTFOUND)
continue;
error = udf_read_node_dscr(cur_node, &dscr);
/* should not fail differently */
if (print_info) {
pwarn("Processing %s\n", udf_node_path(cur_node));
print_info = 0;
}
error = udf_process_file(
dscr,
udf_rw16(cur_node->loc.loc.part_num),
NULL,
AD_FIND_OVERLAP_PAIR,
(void *) cur_node);
/* shouldn't fail */
free(dscr);
}
TAILQ_FOREACH(overlap, &fsck_overlaps, next) {
pwarn("%s :overlaps with %s\n",
udf_node_path(overlap->node),
udf_node_path(overlap->node2));
}
if (!preen)
printf("\n");
pwarn("*** The following files/directories need to be copied/evacuated:\n");
TAILQ_FOREACH(cur_node, &fs_nodes, next) {
if (cur_node->fsck_flags & FSCK_NODE_FLAG_OVERLAP) {
pwarn("%s : found OVERLAP, evacuate\n",
udf_node_path(cur_node));
}
}
}
if (dont_repair) {
if (!preen)
printf("\n");
pwarn("*** Skipping further repair, only updating free space map if needed\n");
pwarn("*** After deep copying and/or evacuation of these files/directories,\n");
pwarn("*** remove files/directories and re-run fsck_udf\n");
error = udf_prepare_writing();
if (error)
return error;
udf_update_lvintd(UDF_INTEGRITY_OPEN);
return 0;
}
/* pass 2a, checking link counts, object sizes and count files/dirs */
if (!preen)
printf("\n\tPass 2, checking link counts, object sizes, stats and cleaning up\n");
TAILQ_FOREACH_SAFE(cur_node, &fs_nodes, next, next_node) {
/* not sane to process files/directories that are not found */
if (cur_node->fsck_flags & FSCK_NODE_FLAG_NOTFOUND)
continue;
/* shadow VAT */
udf_shadow_VAT_in_use(&cur_node->loc);
/* link counts */
if (cur_node->found_link_count != cur_node->link_count) {
pwarn("%s : link count incorrect; "
"%u instead of declared %u : FIXED\n",
udf_node_path(cur_node),
cur_node->found_link_count, cur_node->link_count);
cur_node->link_count = cur_node->found_link_count;
udf_recursive_keep(cur_node);
cur_node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
}
/* object sizes */
if (cur_node->declared.obj_size != cur_node->found.obj_size) {
pwarn("%s : recorded object size incorrect; "
"%" PRIu64 " instead of declared %" PRIu64 "\n",
udf_node_path(cur_node),
cur_node->found.obj_size, cur_node->declared.obj_size);
cur_node->declared.obj_size = cur_node->found.obj_size;
udf_recursive_keep(cur_node);
cur_node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
}
/* XXX TODO XXX times */
/* XXX TODO XXX extended attributes location for UDF < 1.50 */
/* validity of UniqueID check */
if (cur_node->parent) {
if (cur_node->fsck_flags & FSCK_NODE_FLAG_NEW_UNIQUE_ID) {
pwarn("%s : assigning new UniqueID\n",
udf_node_path(cur_node));
cur_node->unique_id = udf_rw64(context.unique_id);
udf_advance_uniqueid();
udf_recursive_keep(cur_node);
cur_node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
if (cur_node->fsck_flags & FSCK_NODE_FLAG_DIRECTORY)
cur_node->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
cur_node->parent->fsck_flags |= FSCK_NODE_FLAG_REPAIRDIR;
}
if (cur_node->fsck_flags & FSCK_NODE_FLAG_COPY_PARENT_ID) {
/* work already done but make note to operator */
pwarn("%s : fixing stream UniqueID to match parent\n",
udf_node_path(cur_node));
}
} else {
if (cur_node->unique_id != 0) {
pwarn("%s : bad UniqueID, zeroing\n",
udf_node_path(cur_node));
cur_node->unique_id = 0;
cur_node->fsck_flags |=
FSCK_NODE_FLAG_DIRTY | FSCK_NODE_FLAG_REPAIRDIR;
}
}
/* keep nodes in a repairing dir */
if (cur_node->parent)
if (cur_node->parent->fsck_flags & FSCK_NODE_FLAG_REPAIRDIR)
cur_node->fsck_flags |= FSCK_NODE_FLAG_KEEP;
/* stream directories and files in it are not included */
if (!(cur_node->fsck_flags & FSCK_NODE_FLAG_STREAM)) {
/* files / directories counting */
int link_count = cur_node->found_link_count;
/* stream directories don't count as link ECMA 4/14.9.6 */
if (cur_node->fsck_flags & FSCK_NODE_FLAG_HAS_STREAM_DIR)
link_count--;
if (cur_node->fsck_flags & FSCK_NODE_FLAG_DIRECTORY)
context.num_directories++;
else
context.num_files += link_count;
;
}
}
/* pass 2b, cleaning */
open_integrity = 0;
TAILQ_FOREACH_SAFE(cur_node, &fs_nodes, next, next_node) {
/* can we remove the node? (to save memory) */
if (FSCK_NODE_FLAG_OK(cur_node->fsck_flags)) {
TAILQ_REMOVE(&fs_nodes, cur_node, next);
LIST_REMOVE(cur_node, next_hash);
free(cur_node->directory);
bzero(cur_node, sizeof(struct udf_fsck_node));
free(cur_node);
} else {
/* else keep erroring node */
open_integrity = 1;
}
}
if (!preen)
printf("\n\tPreparing disc for writing\n");
error = udf_prepare_writing();
if (error)
return error;
if (open_integrity)
udf_update_lvintd(UDF_INTEGRITY_OPEN);
/* pass 3 */
if (!preen)
printf("\n\tPass 3, fix errors\n");
TAILQ_FOREACH_SAFE(cur_node, &fs_nodes, next, next_node) {
/* not sane to process files/directories that are not found */
if (cur_node->fsck_flags & FSCK_NODE_FLAG_NOTFOUND)
continue;
/* only interested in bad nodes */
if (FSCK_NODE_FLAG_OK(cur_node->fsck_flags))
continue;
error = udf_read_node_dscr(cur_node, &dscr);
/* should not fail differently */
/* repair directories */
if (cur_node->fsck_flags & FSCK_NODE_FLAG_REPAIRDIR)
udf_node_pass3_repairdir(cur_node, dscr);
/* remove invalid stream directories */
if (cur_node->fsck_flags & FSCK_NODE_FLAG_WIPE_STREAM_DIR) {
assert(udf_rw16(dscr->tag.id) == TAGID_EXTFENTRY);
bzero(&dscr->efe.streamdir_icb, sizeof(struct long_ad));
cur_node->fsck_flags |= FSCK_NODE_FLAG_DIRTY;
}
if (cur_node->fsck_flags & FSCK_NODE_FLAG_DIRTY)
udf_node_pass3_writeout_update(cur_node, dscr);
free(dscr);
}
udf_check_shadow_VAT();
return 0;
}
static void
udf_cleanup_after_check(void)
{
struct udf_fsck_node *cur_node, *next_node;
/* XXX yes, there are some small memory leaks here */
/* clean old node info from previous checks */
TAILQ_FOREACH_SAFE(cur_node, &fs_nodes, next, next_node) {
TAILQ_REMOVE(&fs_nodes, cur_node, next);
LIST_REMOVE(cur_node, next_hash);
free(cur_node->directory);
free(cur_node);
}
/* free partition related info */
for (int i = 0; i < UDF_PARTITIONS; i++) {
free(context.partitions[i]);
free(context.part_unalloc_bits[i]);
free(context.part_freed_bits[i]);
}
/* only free potentional big blobs */
free(context.vat_contents);
free(context.lvint_history);
free(shadow_vat_contents);
shadow_vat_contents = NULL;
}
static int
checkfilesys(char *given_dev)
{
struct mmc_trackinfo ti;
int open_flags;
int error;
udf_init_create_context();
context.app_name = "*NetBSD UDF";
context.app_version_main = APP_VERSION_MAIN;
context.app_version_sub = APP_VERSION_SUB;
context.impl_name = IMPL_NAME;
emul_mmc_profile = -1; /* invalid->no emulation */
emul_packetsize = 1; /* reasonable default */
emul_sectorsize = 512; /* minimum allowed sector size */
emul_size = 0; /* empty */
if (!preen)
pwarn("** Checking UDF file system on %s\n", given_dev);
/* reset sticky flags */
rdonly = rdonly_flag;
undo_opening_session = 0; /* trying to undo opening of last crippled session */
vat_writeout = 0; /* to write out the VAT anyway */
/* open disc device or emulated file */
open_flags = rdonly ? O_RDONLY : O_RDWR;
if (udf_opendisc(given_dev, open_flags)) {
udf_closedisc();
warnx("can't open %s", given_dev);
return FSCK_EXIT_CHECK_FAILED;
}
if (!preen)
pwarn("** Phase 1 - discovering format from disc\n\n");
/* check if it is an empty disc or no disc in present */
ti.tracknr = mmc_discinfo.first_track;
error = udf_update_trackinfo(&ti);
if (error || (ti.flags & MMC_TRACKINFO_BLANK)) {
/* no use erroring out */
pwarn("Empty disc\n");
return FSCK_EXIT_OK;
}
context.format_flags = 0;
if (mmc_discinfo.mmc_cur & MMC_CAP_SEQUENTIAL)
context.format_flags |= FORMAT_SEQUENTIAL;
if ((context.format_flags & FORMAT_SEQUENTIAL) &&
((mmc_discinfo.disc_state == MMC_STATE_CLOSED) ||
(mmc_discinfo.disc_state == MMC_STATE_FULL))) {
pwarn("Disc is closed or full, can't modify disc\n");
rdonly = 1;
}
if (target_session) {
context.create_new_session = 1;
if (target_session < 0)
target_session += mmc_discinfo.num_sessions;
} else {
target_session = mmc_discinfo.num_sessions;
if (mmc_discinfo.last_session_state == MMC_STATE_EMPTY)
target_session--;
}
error = udf_get_anchors();
if (error) {
udf_closedisc();
pwarn("Failed to retrieve anchors; can't check file system\n");
return FSCK_EXIT_CHECK_FAILED;
}
udf_check_vrs9660();
/* get both VRS areas */
error = udf_check_VDS_areas();
if (error) {
udf_closedisc();
pwarn("Failure reading volume descriptors, disc might be toast\n");
return FSCK_EXIT_CHECK_FAILED;
}
if (udf_rw32(context.logvol_integrity->integrity_type) ==
UDF_INTEGRITY_CLOSED) {
if (!force) {
pwarn("** File system is clean; not checking\n");
return FSCK_EXIT_OK;
}
pwarn("** File system is already clean\n");
if (!preen)
pwarn("\n");
} else {
pwarn("** File system not closed properly\n");
if (!preen)
printf("\n");
}
/*
* Only now read in free/unallocated space bitmap. If it reads in fine
* it doesn't mean its contents is valid though. Sets partition
* lengths too.
*/
error = udf_readin_partitions_free_space();
if (error) {
pwarn("Error during free space bitmap reading\n");
udf_update_lvintd(UDF_INTEGRITY_OPEN);
}
if (!preen)
pwarn("** Phase 2 - walking directory tree\n");
udf_suspend_writing();
error = udf_check_directory_tree();
if (error) {
if ((!rdonly) && ask(0, "Write out modifications made until now"))
udf_allow_writing();
else
pwarn("** Aborting repair, not modifying disc\n");
udf_closedisc();
return FSCK_EXIT_CHECK_FAILED;
}
if (!preen)
pwarn("\n** Phase 3 - closing volume if needed\n\n");
/* XXX FAULT INJECTION POINT XXX */
//udf_update_lvintd(UDF_INTEGRITY_OPEN);
if (error && rdonly) {
pwarn("** Aborting repair, nothing written, disc marked read-only\n");
} else {
error = udf_close_volume();
}
udf_closedisc();
if (error)
return FSCK_EXIT_CHECK_FAILED;
return FSCK_EXIT_OK;
}
static void
usage(void)
{
(void)fprintf(stderr, "Usage: %s [-fHnpSsy] file-system ... \n",
getprogname());
exit(FSCK_EXIT_USAGE);
}
static void
got_siginfo(int signo)
{
print_info = 1;
}
int
main(int argc, char **argv)
{
int ret = FSCK_EXIT_OK, erg;
int ch;
while ((ch = getopt(argc, argv, "ps:SynfH")) != -1) {
switch (ch) {
case 'H':
heuristics = 1;
break;
case 'f':
force = 1;
break;
case 'n':
rdonly_flag = alwaysno = 1;
alwaysyes = preen = 0;
break;
case 'y':
alwaysyes = 1;
alwaysno = preen = 0;
break;
case 'p':
/* small automatic repairs */
preen = 1;
alwaysyes = alwaysno = 0;
break;
case 's':
/* session number or relative session */
target_session = atoi(optarg);
break;
case 'S': /* Search for older VATs */
search_older_vat = 1;
break;
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (!argc)
usage();
/* TODO SIGINT and SIGQUIT catchers */
#if 0
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
(void) signal(SIGINT, catch);
if (preen)
(void) signal(SIGQUIT, catch);
#endif
signal(SIGINFO, got_siginfo);
while (--argc >= 0) {
setcdevname(*argv, preen);
erg = checkfilesys(*argv++);
if (erg > ret)
ret = erg;
if (!preen)
printf("\n");
udf_cleanup_after_check();
}
return ret;
}
/*VARARGS*/
static int __printflike(2, 3)
ask(int def, const char *fmt, ...)
{
va_list ap;
char prompt[256];
int c;
va_start(ap, fmt);
vsnprintf(prompt, sizeof(prompt), fmt, ap);
va_end(ap);
if (alwaysyes || rdonly) {
pwarn("%s? %s\n", prompt, rdonly ? "no" : "yes");
return !rdonly;
}
if (preen) {
pwarn("%s? %s : (default)\n", prompt, def ? "yes" : "no");
return def;
}
do {
pwarn("%s? [yn] ", prompt);
fflush(stdout);
c = getchar();
while (c != '\n' && getchar() != '\n')
if (feof(stdin))
return 0;
} while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
return c == 'y' || c == 'Y';
}
/*VARARGS*/
static int __printflike(2, 3)
ask_noauto(int def, const char *fmt, ...)
{
va_list ap;
char prompt[256];
int c;
va_start(ap, fmt);
vsnprintf(prompt, sizeof(prompt), fmt, ap);
va_end(ap);
#if 0
if (preen) {
pwarn("%s? %s : (default)\n", prompt, def ? "yes" : "no");
return def;
}
#endif
do {
pwarn("%s? [yn] ", prompt);
fflush(stdout);
c = getchar();
while (c != '\n' && getchar() != '\n')
if (feof(stdin))
return 0;
} while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
return c == 'y' || c == 'Y';
}
Reference in New Issue View Git Blame Copy Permalink