/* $NetBSD: main.c,v 1.13 2022/04/25 15:37:14 reinoud 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.13 2022/04/25 15:37:14 reinoud 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, ×pec); 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); } 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); } /* 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'; }