chiark - git - mdw - dvdrip/blob - dvd-sector-copy.c

   1 #define _GNU_SOURCE
   2 #define _FILE_OFFSET_BITS 64
   3
   4 #include <assert.h>
   5 #include <ctype.h>
   6 #include <errno.h>
   7 #include <inttypes.h>
   8 #include <math.h>
   9 #include <stdarg.h>
  10 #include <stdint.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <time.h>
  15
  16 #include <unistd.h>
  17 #include <fcntl.h>
  18 #include <sys/ioctl.h>
  19 #include <sys/stat.h>
  20 #include <sys/time.h>
  21
  22 #include <getopt.h>
  23
  24 #include <linux/fs.h>
  25
  26 #include <dvdread/dvd_reader.h>
  27 #include <dvdread/dvd_udf.h>
  28 #include <dvdread/ifo_read.h>
  29 #include <dvdread/ifo_types.h>
  30
  31 #define CTYPE_HACK(fn, ch) fn((unsigned char)(ch))
  32 #define ISDIGIT(ch) CTYPE_HACK(isdigit, ch)
  33 #define ISSPACE(ch) CTYPE_HACK(isspace, ch)
  34
  35 #define N(v) (sizeof(v)/sizeof((v)[0]))
  36
  37 #define SECTORSZ 2048
  38 #define SECTORS(n) (((n) + (SECTORSZ - 1))/SECTORSZ)
  39
  40 static const char *prog = "<unset>";
  41 static int status = 0;
  42
  43 static void usage(FILE *fp)
  44 {
  45   fprintf(fp,
  46           "usage: %s [-c] [-D DEV] [-R MAP] "
  47                 "[-b OUTMAP] [-o OUTFILE] [-r [START]-[END]]\n",
  48           prog);
  49 }
  50
  51 static void vmoan(const char *fmt, va_list ap)
  52   { fprintf(stderr, "%s: ", prog); vfprintf(stderr, fmt, ap); }
  53
  54 __attribute__((format(printf, 1, 2)))
  55 static void moan(const char *fmt, ...)
  56 {
  57   va_list ap;
  58
  59   va_start(ap, fmt); vmoan(fmt, ap); va_end(ap);
  60   fputc('\n', stderr);
  61 }
  62
  63 __attribute__((noreturn, format(printf, 1, 2)))
  64 static void bail(const char *fmt, ...)
  65 {
  66   va_list ap;
  67
  68   va_start(ap, fmt); vmoan(fmt, ap); va_end(ap);
  69   fputc('\n', stderr);
  70   exit(2);
  71 }
  72
  73 __attribute__((noreturn, format(printf, 2, 3)))
  74 static void bail_syserr(int err, const char *fmt, ...)
  75 {
  76   va_list ap;
  77
  78   va_start(ap, fmt); vmoan(fmt, ap); va_end(ap);
  79   if (err) fprintf(stderr, ": %s", strerror(errno));
  80   fputc('\n', stderr);
  81   exit(2);
  82 }
  83
  84 #define DEFVEC(vtype, etype)                                            \
  85         typedef struct { etype *v; size_t n, sz; } vtype
  86 #define VEC_INIT { 0, 0, 0 }
  87 #define VEC_FREE(vv) do {                                               \
  88   free((vv)->v); (vv)->v 0; (vv)->n = (vv)->sz = 0;                     \
  89 } while (0)
  90 #define VEC_PUSH(p, vv) do {                                            \
  91   size_t _want;                                                         \
  92   if ((vv)->n >= (vv)->sz) {                                            \
  93     (vv)->sz = (vv)->sz ? 2*(vv)->sz : 32;                              \
  94     _want = (vv)->sz*sizeof(*(vv)->v);                                  \
  95     (vv)->v = realloc((vv)->v, _want);                                  \
  96     if (!(vv)->v) bail("out of memory allocating %zu bytes", _want);    \
  97   }                                                                     \
  98   (p) = &(vv)->v[(vv)->n++];                                            \
  99 } while (0)
 100
 101 enum { RAW, IFO, VOB, BUP };
 102 typedef uint_least32_t ident;
 103
 104 static inline ident mkident(unsigned kind, unsigned title, unsigned part)
 105   { return (((ident)kind << 0) | ((ident)title << 8) | ((ident)part << 16)); }
 106 static inline unsigned id_kind(ident id) { return ((id >> 0)&0x0ff); }
 107 static inline unsigned id_title(ident id) { return ((id >> 8)&0x0ff); }
 108 static inline unsigned id_part(ident id) { return ((id >> 16)&0x0ff); }
 109
 110 #define MAXFNSZ (1 + 8 + 1 + 12 + 1)
 111
 112 static void store_filename(char *buf, ident id)
 113 {
 114   switch (id_kind(id)) {
 115     case RAW:
 116       sprintf(buf, "#<raw device>");
 117       break;
 118     case IFO:
 119       if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.IFO");
 120       else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.IFO", id_title(id));
 121       break;
 122     case BUP:
 123       if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.BUP");
 124       else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.BUP", id_title(id));
 125       break;
 126     case VOB:
 127       if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.VOB");
 128       else
 129         sprintf(buf, "/VIDEO_TS/VTS_%02u_%u.VOB", id_title(id), id_part(id));
 130       break;
 131     default:
 132       abort();
 133   }
 134 }
 135
 136 typedef uint_least32_t secaddr;
 137 #define PRIuSEC PRIuLEAST32
 138
 139 #define MAXFILES (1 + 2*99 + 1)
 140 struct file {
 141   ident id;
 142   secaddr start, end;
 143 };
 144 DEFVEC(file_v, struct file);
 145 static file_v filetab = VEC_INIT;
 146
 147 enum { EV_STOP, EV_BEGIN, EV_END, EV_WRITE };
 148 struct event {
 149   unsigned char ev, file;
 150   secaddr pos;
 151 };
 152 DEFVEC(event_v, struct event);
 153 static event_v eventq = VEC_INIT;
 154
 155 static int compare_event(const void *a, const void *b)
 156 {
 157   const struct event *eva = a, *evb = b;
 158
 159   if (eva->pos < evb->pos) return (-1);
 160   else if (eva->pos > evb->pos) return (+1);
 161
 162   if (eva->ev < evb->ev) return (-1);
 163   else if (eva->ev > evb->ev) return (+1);
 164
 165   if (eva->file < evb->file) return (-1);
 166   else if (eva->file > evb->file) return (+1);
 167
 168   return (0);
 169 }
 170
 171 typedef uint_least32_t bits;
 172 static bits live[(MAXFILES + 31)/32];
 173
 174 static inline int livep(unsigned i)
 175   { return (live[i/32]&((bits)1 << (i%32))); }
 176 static inline void set_live(unsigned i)
 177   { live[i/32] |= (bits)1 << (i%32); }
 178 static inline void clear_live(unsigned i)
 179   { live[i/32] &= ~((bits)1 << (i%32)); }
 180 static inline int least_live(void)
 181 {
 182   unsigned i, n = (filetab.n + 32)/32;
 183   bits b;
 184
 185   for (i = 0; i < n; i++) { b = live[i]; if (b) goto found; }
 186   return (-1);
 187 found:
 188   i *= 32;
 189   if (!(b&0x0000ffff)) { b >>= 16; i += 16; }
 190   if (!(b&0x000000ff)) { b >>=  8; i +=  8; }
 191   if (!(b&0x0000000f)) { b >>=  4; i +=  4; }
 192   if (!(b&0x00000003)) { b >>=  2; i +=  2; }
 193   if (!(b&0x00000001)) { b >>=  1; i +=  1; }
 194   assert(b&1);
 195   return (i);
 196 }
 197
 198 static void put_event(unsigned evtype, unsigned file, secaddr pos)
 199 {
 200   struct event *ev;
 201
 202   VEC_PUSH(ev, &eventq);
 203   ev->ev = evtype; ev->file = file; ev->pos = pos;
 204 }
 205
 206 static void put_file(ident id, secaddr start, secaddr end)
 207 {
 208   struct file *f;
 209   size_t i;
 210
 211   VEC_PUSH(f, &filetab); i = f - filetab.v;
 212   f->id = id; f->start = start; f->end = end;
 213   put_event(EV_BEGIN, i, start);
 214   put_event(EV_END, i, end);
 215 }
 216
 217 static void put_menu(dvd_reader_t *dvd, unsigned title)
 218 {
 219   ident id = mkident(VOB, title, 0);
 220   char fn[MAXFNSZ];
 221   secaddr start, len;
 222
 223   store_filename(fn, id);
 224   start = UDFFindFile(dvd, fn, &len); if (!start) return;
 225 #ifdef DEBUG
 226       printf(";; %8"PRIuSEC" .. %-8"PRIuSEC": %s\n",
 227              start, start + SECTORS(len), fn);
 228 #endif
 229   put_file(id, start, start + SECTORS(len));
 230 }
 231
 232 static void put_title(dvd_reader_t *dvd, unsigned title)
 233 {
 234   char fn[MAXFNSZ];
 235   secaddr start[9], len[9];
 236   unsigned i, npart;
 237
 238   for (i = 0; i < 9; i++) {
 239     store_filename(fn, mkident(VOB, title, i + 1));
 240     start[i] = UDFFindFile(dvd, fn, &len[i]); if (!start[i]) break;
 241   }
 242   npart = i; if (!npart) return;
 243
 244 #ifdef DEBUG
 245   for (i = 0; i < npart; i++) {
 246     store_filename(fn, mkident(VOB, title, i + 1));
 247     printf(";; %8"PRIuSEC" .. %-8"PRIuSEC": %s\n",
 248            start[i], start[i] + SECTORS(len[i]), fn);
 249   }
 250 #endif
 251
 252   if (npart > 1)
 253     for (i = 0; i < npart - 1; i++) {
 254       if (len[i]%SECTORSZ)
 255         bail("title %u part %u length = %"PRIuSEC" not a multiple of %d",
 256              title, i, len[i], SECTORSZ);
 257       if (start[i] + len[i]/SECTORSZ != start[i + 1])
 258         bail
 259           ("title %u part %u end = %"PRIuSEC" /= part %u start = %"PRIuSEC"",
 260            title, i, start[i] + len[i]/SECTORSZ, i + 1, start[i + 1]);
 261     }
 262
 263   put_file(mkident(VOB, title, 1),
 264            start[0], start[npart - 1] + SECTORS(len[npart - 1]));
 265 }
 266
 267 static int progresslen = 0;
 268
 269 static void clear_progress_internal(void)
 270   { while (progresslen) { fputs("\b \b", stdout); progresslen--; } }
 271 static void clear_progress(void)
 272   { clear_progress_internal(); fflush(stdout); }
 273 static void vappend_progress(const char *fmt, va_list ap)
 274   { progresslen += vprintf(fmt, ap); }
 275 __attribute__((format(printf, 1, 2)))
 276 static void append_progress(const char *fmt, ...)
 277 {
 278   va_list ap;
 279
 280   va_start(ap, fmt);
 281   vappend_progress(fmt, ap);
 282   va_end(ap);
 283 }
 284 __attribute__((format(printf, 1, 2)))
 285 static void print_progress(const char *fmt, ...)
 286 {
 287   va_list ap;
 288
 289   va_start(ap, fmt);
 290   clear_progress_internal();
 291   vappend_progress(fmt, ap);
 292   va_end(ap);
 293 }
 294
 295 unsigned flags;
 296 #  define F_ALLPROGRESS 1u
 297 static secaddr last_pos, limit, nsectors, ndone;
 298 static struct timeval last_time;
 299 static double wsum, wcount;
 300 static struct file *file;
 301
 302 static void report_progress(secaddr pos)
 303 {
 304   char etastr[32];
 305   struct timeval now;
 306   int eta;
 307   double percent, t, f, g, rate;
 308   char *unit;
 309
 310 #define ALPHA 0.02
 311 #define BETA (1 - ALPHA)
 312
 313   gettimeofday(&now, 0);
 314   t = (now.tv_sec - last_time.tv_sec) +
 315     (now.tv_usec - last_time.tv_usec)/1000000.0;
 316
 317   if (t) {
 318     g = wcount ? pow(BETA, t) : 0.0; f = (1 - g)/(1 - BETA);
 319     wsum = f*(pos - last_pos)/t + g*wsum;
 320     wcount = f + g*wcount;
 321     ndone += pos - last_pos;
 322     last_time = now; last_pos = pos;
 323   }
 324
 325   if (!wsum || !wcount)
 326     { rate = 0; strcpy(etastr, "???"); }
 327   else {
 328     rate = wsum/wcount;
 329     eta = (int)((nsectors - ndone)/rate);
 330     sprintf(etastr, "%d:%02d:%02d", eta/3600, (eta/60)%60, eta%60);
 331   }
 332
 333   rate *= SECTORSZ; unit = "";
 334   if (rate > 128) { rate /= 1024; unit = "k"; }
 335   if (rate > 128) { rate /= 1024; unit = "M"; }
 336   if (rate > 128) { rate /= 1024; unit = "G"; }
 337
 338   if (flags&F_ALLPROGRESS) percent = pos*100.0/limit;
 339   else percent = ndone*100.0/nsectors;
 340   print_progress
 341     ("copied %.1f%% (%"PRIuSEC" of %"PRIuSEC"; %.1f %sB/s, ETA %s)",
 342      percent, pos, limit,  rate, unit, etastr);
 343   if (file && id_kind(file->id) == VOB) {
 344     append_progress(" -- %s %d %3.1f%%",
 345                     id_part(file->id) ? "title" : "menu",
 346                     id_title(file->id),
 347                     (pos - file->start)*100.0/
 348                       (file->end - file->start));
 349   }
 350
 351 #undef ALPHA
 352 #undef BETA
 353 }
 354
 355 static void report_bad_blocks_progress(secaddr lo, secaddr hi, int err)
 356 {
 357   report_progress(hi);
 358
 359   if (lo == hi) append_progress(": retrying bad sector");
 360   else
 361     append_progress(": %"PRIuSEC" bad %s",
 362                     hi - lo, hi == lo + 1 ? "sector" : "sectors");
 363   if (err != EIO) append_progress(" (%s)", strerror(err));
 364   fflush(stdout);
 365 }
 366
 367 static dvd_reader_t *dvd;
 368 static int dvdfd = -1;
 369 static dvd_file_t *vob;
 370 static const char *mapfile; static FILE *mapfp;
 371
 372 static ssize_t read_sectors(secaddr pos, void *buf, secaddr want)
 373 {
 374   ssize_t n;
 375
 376 again:
 377   if (vob)
 378     n = DVDReadBlocks(vob, pos - file->start, want, buf);
 379   else if (file) {
 380     if (lseek(dvdfd, (off_t)pos*SECTORSZ, SEEK_SET) < 0)
 381       bail_syserr(errno, "failed to seek to sector %"PRIuSEC"", pos);
 382     n = read(dvdfd, buf, want*SECTORSZ);
 383     if (n >= 0) n /= SECTORSZ;
 384   } else {
 385     memset(buf, 0, want*SECTORSZ);
 386     n = want;
 387   }
 388
 389   if (n < 0 && errno == EINTR) goto again;
 390   return (n);
 391 }
 392
 393 static void carefully_write(int fd, const void *buf, size_t sz)
 394 {
 395   const unsigned char *p = buf;
 396   ssize_t n;
 397
 398   if (fd < 0) return;
 399   while (sz) {
 400     n = write(fd, p, sz);
 401     if (n < 0) {
 402       if (errno == EINTR) continue;
 403       bail_syserr(errno, "failed to write to output file");
 404     }
 405     if (!n) bail("unexpected short write to output file");
 406     p += n; sz -= n;
 407   }
 408 }
 409
 410 static void emit(int outfd, secaddr start, secaddr end)
 411 {
 412 #define BUFSECTORS 512
 413
 414   int least, i;
 415   unsigned char buf[BUFSECTORS*SECTORSZ];
 416   secaddr pos;
 417   secaddr bad_lo, bad_hi, good, step;
 418   size_t want;
 419   ssize_t n;
 420   static int first_time = 1;
 421 #ifdef DEBUG
 422   struct file *f;
 423   char fn[MAXFNSZ];
 424   int act = -1;
 425 #endif
 426
 427   least = least_live();
 428
 429 #ifdef DEBUG
 430   printf(";; %8"PRIuSEC" .. %"PRIuSEC"\n", start, end);
 431
 432   for (i = 0; i < filetab.n; i++) {
 433     if (!livep(i)) continue;
 434     if (act == -1) act = i;
 435     f = &filetab.v[i]; store_filename(fn, f->id);
 436     printf(";;\t\t%8"PRIuSEC" .. %-8"PRIuSEC" %s\n",
 437            start - f->start, end - f->start, fn);
 438   }
 439   if (act == -1) printf(";;\t\t#<no live source>\n");
 440   assert(act == least);
 441 #endif
 442
 443   if (least == -1)
 444     { file = 0; vob = 0; }
 445   else {
 446     file = &filetab.v[least];
 447     switch (id_kind(file->id)) {
 448       case RAW:
 449         vob = 0;
 450         break;
 451       case VOB:
 452         if (first_time) { clear_progress(); first_time = 0; }
 453         vob = DVDOpenFile(dvd, id_title(file->id),
 454                           id_part(file->id)
 455                             ? DVD_READ_TITLE_VOBS
 456                             : DVD_READ_MENU_VOBS);
 457         if (!vob)
 458           bail("failed to open %s %u",
 459                id_part(file->id) ? "title" : "menu",
 460                id_title(file->id));
 461         break;
 462       default:
 463         abort();
 464     }
 465   }
 466
 467   pos = start;
 468   while (pos < end) {
 469     want = end - pos; if (want > BUFSECTORS) want = BUFSECTORS;
 470     n = read_sectors(pos, buf, want);
 471
 472     if (n <= 0) {
 473       report_bad_blocks_progress(pos, pos, errno);
 474       for (i = 0; i < 4; i++) {
 475         n = read_sectors(pos, buf, 1);
 476         if (n > 0) {
 477           clear_progress();
 478           moan("sector %"PRIuSEC" read ok after retry", pos);
 479           bad_lo = bad_hi = pos;
 480           goto recovered;
 481         }
 482       }
 483
 484       bad_lo = pos; step = 1; bad_hi = pos + 1;
 485       for (;;) {
 486         report_bad_blocks_progress(bad_lo, bad_hi, errno);
 487         if (bad_hi >= end) {
 488           clear_progress();
 489           moan("giving up on this extent");
 490           n = 0; goto recovered;
 491         }
 492         step *= 2;
 493         if (step > end - bad_lo) step = end - bad_lo;
 494         pos = bad_lo + step - 1;
 495         n = read_sectors(pos, buf, 1);
 496         if (n > 0) break;
 497         bad_hi = pos + 1;
 498       }
 499
 500       good = pos;
 501       while (good > bad_hi) {
 502         report_bad_blocks_progress(bad_lo, bad_hi, errno);
 503         pos = bad_hi + (good - bad_hi)/2;
 504         n = read_sectors(pos, buf, 1);
 505         if (n > 0) good = pos;
 506         else bad_hi = pos + 1;
 507       }
 508     recovered:
 509       if (bad_hi > bad_lo) {
 510         clear_progress();
 511         moan("skipping %"PRIuSEC" bad sectors (%"PRIuSEC" .. %"PRIuSEC")",
 512              bad_hi - bad_lo, bad_lo, bad_hi);
 513         if (mapfile) {
 514           if (!mapfp) {
 515             mapfp = fopen(mapfile, "w");
 516             if (!mapfp)
 517               bail_syserr(errno, "failed to open bad-sector map file `%s'",
 518                           optarg);
 519             fprintf(mapfp, "## bad sector map\n\n");
 520           }
 521           fprintf(mapfp, "%"PRIuSEC" %"PRIuSEC"\n", bad_lo, bad_hi);
 522           fflush(mapfp);
 523           if (ferror(mapfp))
 524             bail_syserr(errno, "error writing bad-sector map file");
 525         }
 526         if (outfd >= 0 &&
 527             lseek(outfd, (off_t)(bad_hi - bad_lo)*SECTORSZ, SEEK_CUR) < 0)
 528           bail_syserr(errno, "failed to seek past bad sectors");
 529         status = 1;
 530       }
 531       pos = bad_hi;
 532     }
 533
 534     if (n > 0) { carefully_write(outfd, buf, n*SECTORSZ); pos += n; }
 535     report_progress(pos); fflush(stdout);
 536   }
 537
 538   if (vob) { DVDCloseFile(vob); vob = 0; }
 539
 540 #undef BUFSECTORS
 541 }
 542
 543 #ifdef notdef
 544 static void logfn(void *p, dvd_logger_level_t lev,
 545                   const char *fmt, va_list ap)
 546 {
 547   switch (lev) {
 548     case DVD_LOGGER_LEVEL_ERROR:
 549       fprintf("%s (libdvdread error): ", prog);
 550       break;
 551     case DVD_LOGGER_LEVEL_WARN:
 552       fprintf("%s (libdvdread warning): ", prog);
 553       break;
 554     default:
 555       return;
 556   }
 557   vfprintf(stderr, fmt, ap);
 558   fputc('\n', stderr);
 559 }
 560 static const dvd_logger_cb logger = { logfn };
 561 #endif
 562
 563 struct buf {
 564   char *p;
 565   size_t n, sz;
 566 };
 567 #define BUF_INIT { 0, 0, 0 }
 568 #define BUF_REWIND(b) do { (b)->n = 0; } while (0)
 569 #define BUF_FREE(b) do {                                                \
 570   buf *_b = (b);                                                        \
 571   free(_b->p); _b->p = 0; _b->n = _b->sz = 0;                           \
 572 } while (0)
 573 #define BUF_PUTC(b, ch) do {                                            \
 574   struct buf *_b = (b);                                                 \
 575   if (_b->n >= _b->sz) {                                                \
 576     _b->sz = _b->sz ? 2*_b->sz : 32;                                    \
 577     _b->p = realloc(_b->p, _b->sz);                                     \
 578     if (!_b->p) bail("out of memory allocating %zu bytes", _b->sz);     \
 579   }                                                                     \
 580   _b->p[_b->n] = (ch);                                                  \
 581 } while (0)
 582
 583 static int read_line(FILE *fp, struct buf *b)
 584 {
 585   int ch;
 586
 587   ch = getc(fp);
 588   if (ch == EOF)
 589     return (-1);
 590   else if (ch != '\n') do {
 591     BUF_PUTC(b, ch); b->n++;
 592     ch = getc(fp);
 593   } while (ch != EOF && ch != '\n');
 594   BUF_PUTC(b, 0);
 595   return (0);
 596 }
 597
 598 int main(int argc, char *argv[])
 599 {
 600   unsigned f = 0;
 601   char *p;
 602   uint64_t volsz;
 603   secaddr pos;
 604   off_t off;
 605   unsigned long start, end;
 606   const struct event *ev;
 607   const char *device = "/dev/dvd", *outfile = 0;
 608   int opt, err, outfd = -1, blksz;
 609   unsigned n;
 610   size_t i;
 611   FILE *fp;
 612   struct buf buf = BUF_INIT;
 613   struct stat st;
 614 #ifdef DEBUG
 615   const struct file *file;
 616   char fn[MAXFNSZ];
 617 #endif
 618
 619 #define f_bogus 1u
 620 #define f_continue 2u
 621 #define f_fixup 4u
 622 #define f_write 256u
 623
 624   p = strrchr(argv[0], '/'); prog = p ? p + 1 : argv[0];
 625   for (;;) {
 626     opt = getopt(argc, argv, "hD:FR:b:co:r:"); if (opt < 0) break;
 627     switch (opt) {
 628       case 'h': usage(stderr); exit(0);
 629       case 'D': device = optarg; break;
 630       case 'F': f |= f_fixup; break;
 631       case 'R':
 632         fp = fopen(optarg, "r");
 633         if (!fp)
 634           bail_syserr(errno, "failed to open ranges file `%s'", optarg);
 635         i = 0;
 636         for (;;) {
 637           BUF_REWIND(&buf); if (read_line(fp, &buf)) break;
 638           p = buf.p; i++;
 639           while (ISSPACE(*p)) p++;
 640           if (!*p || *p == '#') continue;
 641           if (!ISDIGIT(*p)) goto bad_range_file;
 642           start = strtoul(p, &p, 0);
 643           if (errno || !ISSPACE(*p)) goto bad_range_file;
 644           do p++; while (ISSPACE(*p));
 645           if (!ISDIGIT(*p)) goto bad_range_file;
 646           end = strtoul(p, &p, 0);
 647           if (errno || (*p && !ISSPACE(*p))) goto bad_range_file;
 648           while (ISSPACE(*p)) p++;
 649           if (*p) goto bad_range_file;
 650           if (start > end) goto bad_range_file;
 651           if (start < end) {
 652             put_event(EV_WRITE, 0, start);
 653             put_event(EV_STOP, 0, end);
 654           }
 655         }
 656         if (ferror(fp))
 657           bail_syserr(errno, "failed to read ranges file `%s'", optarg);
 658         break;
 659       bad_range_file:
 660         bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
 661       case 'b':
 662         if (mapfile) bail("can't have multiple map files");
 663         mapfile = optarg;
 664         break;
 665       case 'c': f |= f_continue; break;
 666       case 'o': outfile = optarg; break;
 667       case 'r':
 668         err = errno; errno = 0;
 669         p = optarg;
 670         if (*p == '-')
 671           start = 0;
 672         else {
 673           if (!ISDIGIT(*p)) goto bad_range;
 674           start = strtoul(p, &p, 0);
 675           if (errno || *p != '-') goto bad_range;
 676         }
 677         p++;
 678         if (!*p)
 679           put_event(EV_WRITE, 0, start);
 680         else {
 681           if (!ISDIGIT(*p)) goto bad_range;
 682           end = strtoul(p, &p, 0);
 683           if (errno || *p) goto bad_range;
 684           if (start > end) goto bad_range;
 685           if (start < end) {
 686             put_event(EV_WRITE, 0, start);
 687             put_event(EV_STOP, 0, end);
 688           }
 689         }
 690         errno = err;
 691         break;
 692       bad_range:
 693         bail("bad range `%s'", optarg);
 694         break;
 695       default: f |= f_bogus; break;
 696     }
 697   }
 698   if (optind < argc) f |= f_bogus;
 699   if (f&f_bogus) { usage(stderr); exit(2); }
 700
 701   dvdfd = open(device, O_RDONLY);
 702   if (dvdfd < 0)
 703     bail_syserr(errno, "failed to open device `%s'", device);
 704   if (fstat(dvdfd, &st))
 705     bail_syserr(errno, "failed to stat device `%s'", device);
 706   if (S_ISREG(st.st_mode)) {
 707     blksz = SECTORSZ;
 708     volsz = st.st_size;
 709   } else if (S_ISBLK(st.st_mode)) {
 710     if (ioctl(dvdfd, BLKSSZGET, &blksz))
 711       bail_syserr(errno, "failed to get block size for `%s'", device);
 712     if (ioctl(dvdfd, BLKGETSIZE64, &volsz))
 713       bail_syserr(errno, "failed to get volume size for `%s'", device);
 714   } else
 715     bail("can't use `%s' as source: expected file or block device", device);
 716
 717   if (blksz != SECTORSZ)
 718     bail("device `%s' block size %d /= %d", device, blksz, SECTORSZ);
 719   if (volsz%SECTORSZ)
 720     bail("device `%s' volume size %"PRIu64" not a multiple of %d",
 721          device, volsz, SECTORSZ);
 722
 723   if (outfile) {
 724     outfd = open(outfile, O_WRONLY | O_CREAT, 0666);
 725     if (outfd < 0)
 726       bail_syserr(errno, "failed to create output file `%s'", outfile);
 727   }
 728
 729   if (f&f_continue) {
 730     if (!outfile) bail("can't continue without output file");
 731     off = lseek(outfd, 0, SEEK_END);
 732     if (off < 0)
 733       bail_syserr(errno, "failed to seek to end of output file `%s'",
 734                   outfile);
 735     put_event(EV_WRITE, 0, off/SECTORSZ);
 736   } else if (!eventq.n && !(f&f_fixup))
 737     put_event(EV_WRITE, 0, 0);
 738
 739 #ifdef notdef
 740   dvd = DVDOpen2(0, &logger, device);
 741 #else
 742   dvd = DVDOpen(device);
 743 #endif
 744   if (!dvd) bail("failed to open DVD on `%s'", device);
 745
 746   /* It's fast enough just to check everything. */
 747   put_menu(dvd, 0);
 748   for (i = 1; i < 100; i++) {
 749     put_menu(dvd, i);
 750     put_title(dvd, i);
 751   }
 752   put_file(mkident(RAW, 0, 0), 0, volsz/SECTORSZ);
 753   assert(filetab.n <= MAXFILES);
 754
 755   for (i = 0, limit = 0; i < filetab.n; i++)
 756     if (filetab.v[i].end > limit) limit = filetab.v[i].end;
 757
 758   if (end > limit) end = limit;
 759
 760 #ifdef DEBUG
 761   printf("\n;; files:\n");
 762   for (i = 0; i < filetab.n; i++) {
 763     file = &filetab.v[i];
 764     store_filename(fn, file->id);
 765     printf(";;\t%8"PRIuSEC" %s\n", file->start, fn);
 766   }
 767 #endif
 768
 769   qsort(eventq.v, eventq.n, sizeof(struct event), compare_event);
 770
 771   f &= ~f_write; start = 0; n = 0;
 772   for (i = 0; i < eventq.n; i++) {
 773     ev = &eventq.v[i];
 774     switch (ev->ev) {
 775       case EV_WRITE:
 776         if (f&f_write)
 777           bail("overlapping ranges: range from %lu still open at %"PRIuSEC"",
 778                start, ev->pos);
 779         n++; f |= f_write; start = ev->pos;
 780         break;
 781       case EV_STOP:
 782         f &= ~f_write;
 783         break;
 784     }
 785   }
 786
 787   f &= ~f_write; start = 0;
 788   for (i = 0; i < eventq.n; i++) {
 789     ev = &eventq.v[i];
 790     switch (ev->ev) {
 791       case EV_WRITE: start = ev->pos; f |= f_write; break;
 792       case EV_STOP: nsectors += ev->pos - start; f &= ~f_write; break;
 793     }
 794     if (ev->pos >= limit) break;
 795     if (f&f_fixup) start = ev->pos;
 796   }
 797   eventq.n = i;
 798   if (f&f_fixup) {
 799     put_event(EV_WRITE, 0, start);
 800     n++; f |= f_write;
 801   }
 802   if (f&f_write) {
 803     nsectors += limit - start;
 804     put_event(EV_STOP, 0, limit);
 805   }
 806   if (n == 1 && (f&f_write)) flags |= F_ALLPROGRESS;
 807   f &= ~f_write;
 808
 809 #ifdef DEBUG
 810   printf("\n;; event sweep:\n");
 811 #endif
 812   for (pos = 0, i = 0; i < eventq.n; i++) {
 813     ev = &eventq.v[i];
 814     if (ev->pos > pos) {
 815       if (f&f_write) emit(outfd, pos, ev->pos);
 816       pos = ev->pos;
 817 #ifdef DEBUG
 818       clear_progress();
 819       printf(";;\n");
 820 #endif
 821     }
 822     switch (ev->ev) {
 823       case EV_BEGIN:
 824         set_live(ev->file);
 825 #ifdef DEBUG
 826         store_filename(fn, filetab.v[ev->file].id);
 827         clear_progress();
 828         printf(";; %8"PRIuSEC": begin `%s'\n", pos, fn);
 829 #endif
 830         break;
 831       case EV_WRITE:
 832         gettimeofday(&last_time, 0); last_pos = pos;
 833         if (outfd >= 0 &&
 834             lseek(outfd, (off_t)ev->pos*SECTORSZ, SEEK_SET) < 0)
 835           bail_syserr(errno,
 836                       "failed to seek to resume position "
 837                       "(sector %"PRIuSEC") in output file `%s'",
 838                       ev->pos, outfile);
 839 #ifdef DEBUG
 840         clear_progress();
 841         printf(";; %8"PRIuSEC": begin write\n", pos);
 842 #endif
 843         f |= f_write;
 844         break;
 845       case EV_STOP:
 846         f &= ~f_write;
 847 #ifdef DEBUG
 848         clear_progress();
 849         printf(";; %8"PRIuSEC": end write\n", pos);
 850 #endif
 851         break;
 852       case EV_END:
 853         clear_live(ev->file);
 854 #ifdef DEBUG
 855         store_filename(fn, filetab.v[ev->file].id);
 856         clear_progress();
 857         printf(";; %8"PRIuSEC": end `%s'\n", pos, fn);
 858 #endif
 859         break;
 860       default: abort();
 861     }
 862   }
 863
 864   if (progresslen) putchar('\n');
 865
 866   if (outfd >= 0 && ftruncate(outfd, (off_t)limit*SECTORSZ) < 0)
 867     bail_syserr(errno, "failed to set output file `%s' length", outfile);
 868
 869   if (dvd) DVDClose(dvd);
 870   if (dvdfd >= 0) close(dvdfd);
 871   if (outfd >= 0) close(outfd);
 872   if (mapfp) {
 873     if (ferror(mapfp) || fclose(mapfp))
 874       bail_syserr(errno, "error writing bad-sector map file");
 875   }
 876
 877 #undef f_bogus
 878 #undef f_continue
 879 #undef f_fixup
 880 #undef f_write
 881
 882   return (status);
 883 }