[dvdrip] / lib.c

/* -*-c-*-
 *
 * Common functions for the DVDrip C utilities.
 *
 * (c) 2022 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the DVD ripping toolset.
 *
 * DVDrip is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 3 of the License, or (at your
 * option) any later version.
 *
 * DVDrip is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with DVDrip.  If not, see <https://www.gnu.org/licenses/>.
 */

/*----- Header files ------------------------------------------------------*/

#include "lib.h"

/*----- Diagnostics -------------------------------------------------------*/

const char *prog = "<unset>";

void set_prog(const char *p)
  { const char *q = strrchr(p, '/'); prog = q ? q + 1 : p; }

void vmoan(const char *fmt, va_list ap)
  { vmoan_syserr(0, fmt, ap); }

void vmoan_syserr(int err, const char *fmt, va_list ap)
{
  fprintf(stderr, "%s: ", prog);
  vfprintf(stderr, fmt, ap);
  if (err) fprintf(stderr, ": %s", strerror(errno));
  fputc('\n', stderr);
}

void moan(const char *fmt, ...)
  { va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); }

void moan_syserr(int err, const char *fmt, ...)
  { va_list ap; va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap); }

void bail(const char *fmt, ...)
  { va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); exit(2); }

void bail_syserr(int err, const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap);
  exit(2);
}

/*----- Parsing utilities -------------------------------------------------*/

double parse_float(const char **p_inout, unsigned f,
		   double min, double max, const char *what)
{
  const char *p;
  char *q;
  double x;
  int err;

  err = errno; errno = 0;
  p = *p_inout;
  x = strtod(p, &q);
  if (errno || x < min || x > max || (!(f&PNF_JUNK) && *q))
    bail("bad %s `%s'", what, p);
  *p_inout = q; errno = err;
  return (x);
}

long parse_int(const char **p_inout, unsigned f,
	       long min, long max, const char *what)
{
  const char *p;
  char *q;
  long x;
  int err;

  err = errno; errno = 0;
  p = *p_inout;
  x = strtoul(p, &q, 0);
  if (errno || x < min || x > max || (!(f&PNF_JUNK) && *q))
    bail("bad %s `%s'", what, p);
  *p_inout = q; errno = err;
  return (x);
}

/*----- Resizing buffers and arrays ---------------------------------------*/

void buf__grow(struct buf *b)
{
  b->sz = b->sz ? 2*b->sz : 32;
  b->p = realloc(b->p, b->sz);
  if (!b->p) bail("out of memory allocating %zu bytes", b->sz);
}

void *vec__grow(void *p, size_t esz, size_t *sz_inout)
{
  size_t sz = *sz_inout, want;

  sz = sz ? 2*sz : 32;
  want = sz*esz;
  p = realloc(p, want);
  if (!p) bail("out of memory allocating %zu bytes", want);
  *sz_inout = sz; return (p);
}

/*----- System utilities --------------------------------------------------*/

void sit(double t)
{
  struct timeval tv;
  double whole = floor(t);

  if (t) {
    tv.tv_sec = whole; tv.tv_usec = floor((t - whole)*1.0e6) + 1;
    if (select(0, 0, 0, 0, &tv) < 0) bail_syserr(errno, "failed to sleep");
  }
}

double tvdiff(const struct timeval *tv_lo, const struct timeval *tv_hi)
{
  return ((tv_hi->tv_sec - tv_lo->tv_sec) +
	  (tv_hi->tv_usec - tv_lo->tv_usec)/1.0e6);
}

int read_line(FILE *fp, struct buf *b)
{
  int ch;

  ch = getc(fp);
  if (ch == EOF)
    return (-1);
  else if (ch != '\n')
    do { buf_putc(b, ch); ch = getc(fp); } while (ch != EOF && ch != '\n');
  buf_putz(b);
  return (0);
}

void carefully_write(int fd, const void *buf, size_t sz)
{
  const unsigned char *p = buf;
  ssize_t n;

  if (fd < 0) return;
  while (sz) {
    n = write(fd, p, sz);
    if (n < 0) {
      if (errno == EINTR) continue;
      bail_syserr(errno, "failed to write to output file");
    }
    if (!n) bail("unexpected short write to output file");
    p += n; sz -= n;
  }
}

void open_file_on_demand(const char *file, FILE **fp_inout, const char *what)
{
  FILE *fp;

  if (!*fp_inout) {
    fp = fopen(file, "w");
    if (!fp) bail_syserr(errno, "failed to open %s file `%s'", what, file);
    fprintf(fp, "## %s\n\n", what);
    *fp_inout = fp;
  }
}

void check_write(FILE *fp, const char *what)
{
  fflush(fp);
  if (ferror(fp)) bail_syserr(errno, "error writing %s file", what);
}

void carefully_fclose(FILE *fp, const char *what)
{
  if (fp && (ferror(fp) || fclose(fp)))
    bail_syserr(errno, "error writing %s file", what);
}

off_t device_size(int fd, const char *file, int *blksz_out)
{
  struct stat st;
  uint64_t volsz;

  if (fstat(fd, &st))
    bail_syserr(errno, "failed to obtain status for `%s'", file);
  if (S_ISREG(st.st_mode))
    volsz = st.st_size;
  else if (S_ISBLK(st.st_mode)) {
    if (ioctl(fd, BLKGETSIZE64, &volsz))
      bail_syserr(errno, "failed to get volume size for `%s'", file);
    if (ioctl(fd, BLKSSZGET, blksz_out))
      bail_syserr(errno, "failed to get block size for `%s'", file);
  } else
    bail("can't read size for `%s': expected file or block device", file);
  return ((off_t)volsz);
}

/*----- Progress utilities ------------------------------------------------*/

struct progress_state progress = PROGRESS_STATE_INIT;
static struct banner_progress_item banner_progress;

static void render_banner_progress(struct progress_item *item,
			    struct progress_render_state *render)
{
  struct banner_progress_item *bi = (struct banner_progress_item *)item;

  progress_putleft(render, " %s", bi->msg);
  progress_shownotice(render, 4, 7);
}

void show_banner(const char *msg)
{
  banner_progress._base.render = render_banner_progress;
  progress_additem(&progress, &banner_progress._base);
  banner_progress.msg = msg;
  progress_update(&progress);
}

void hide_banner(void)
{
  if (!progress_removeitem(&progress, &banner_progress._base))
    progress_update(&progress);
}

/*----- DVD utilities -----------------------------------------------------*/

#ifdef notdef
static void logfn(void *p, dvd_logger_level_t lev,
		  const char *fmt, va_list ap)
{
  switch (lev) {
    case DVD_LOGGER_LEVEL_ERROR:
      fprintf("%s (libdvdread error): ", prog);
      break;
    case DVD_LOGGER_LEVEL_WARN:
      fprintf("%s (libdvdread warning): ", prog);
      break;
    default:
      return;
  }
  vfprintf(stderr, fmt, ap);
  fputc('\n', stderr);
}
static const dvd_logger_cb logger = { logfn };
#endif

void open_dvd(const char *device, int mode,
	      int *fd_out, dvd_reader_t **dvd_out)
{
  int fd;
  dvd_reader_t *dvd;
  int bannerp = 0;

  for (;;) {
    fd = open(device, mode);
    if (fd >= 0 || errno != ENOMEDIUM) break;
    if (!bannerp) {
      show_banner("Waiting for disc to be inserted...");
      bannerp = 1;
    }
    sit(0.2);
  }
  if (bannerp) hide_banner();
  if (fd < 0) bail_syserr(errno, "failed to open device `%s'", device);
  if (dvd_out) {
#ifdef notdef
    dvd = DVDOpen2(0, &logger, device);
#else
    dvd = DVDOpen(device);
#endif
    if (!dvd) bail("failed to open DVD on `%s'", device);
    *dvd_out = dvd;
  }
  if (fd_out) *fd_out = fd;
  else close(fd);
}

void store_filename(char *buf, ident id)
{
  switch (id_kind(id)) {
    case RAW:
      sprintf(buf, "#<raw device>");
      break;
    case IFO:
      if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.IFO");
      else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.IFO", id_title(id));
      break;
    case BUP:
      if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.BUP");
      else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.BUP", id_title(id));
      break;
    case VOB:
      if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.VOB");
      else
	sprintf(buf, "/VIDEO_TS/VTS_%02u_%u.VOB", id_title(id), id_part(id));
      break;
    default:
      abort();
  }
}

static char *copy_string(char *p, const char *q)
{
  while (*q) *p++ = *q++;
  *p = 0; return (p);
}

static char *copy_hex(char *p, const unsigned char *q, size_t sz)
{
  while (sz) {
    sprintf(p, "%02x", *q);
    p += 2; q++; sz--;
  }
  return (p);
}

int dvd_id(char *p, dvd_reader_t *dvd, unsigned f, const char *file)
{
  char volid[33];
  unsigned char volsetid[16], discid[16];
  int rc;
  size_t n;

  rc = DVDUDFVolumeInfo(dvd,
			volid, sizeof(volid),
			volsetid, sizeof(volsetid));
  if (!rc) {
    p = copy_string(p, volid);
    *p++ = '-';
    for (n = sizeof(volsetid); n && !volsetid[n - 1]; n--);
    p = copy_hex(p, volsetid, n);
  } else if (f&DIF_MUSTVOLINF) {
    if (file) moan("failed to read volume info for `%s'", file);
    else moan("failed to read volume info");
    return (-1);
  } else
    p = copy_string(p, "<error reading volume info>");

  *p++ = ':';
  rc = DVDDiscID(dvd, discid);
  if (!rc)
    p = copy_hex(p, discid, sizeof(discid));
  else if (f&DIF_MUSTIFOHASH) {
    if (file) moan("failed to determine disc id of `%s'", file);
    else moan("failed to determine disc id");
    return (-1);
  } else
    p = copy_string(p, "<error reading disc-id>");

  return (0);
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
be15bd14 MW	1	/* --c--
	2	*
	3	* Common functions for the DVDrip C utilities.
	4	*
	5	* (c) 2022 Mark Wooding
	6	*/
	7
	8	/----- Licensing notice --------------------------------------------------
	9	*
	10	* This file is part of the DVD ripping toolset.
	11	*
	12	* DVDrip is free software: you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by the
	14	* Free Software Foundation; either version 3 of the License, or (at your
	15	* option) any later version.
	16	*
	17	* DVDrip is distributed in the hope that it will be useful, but WITHOUT
	18	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	19	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	20	* for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with DVDrip. If not, see <https://www.gnu.org/licenses/>.
	24	*/
	25
	26	/----- Header files ------------------------------------------------------/
	27
dc53ebfa MW	28	#include "lib.h"
dc53ebfa MW	29
be15bd14 MW	30	/----- Diagnostics -------------------------------------------------------/
be15bd14 MW	31
dc53ebfa MW	32	const char *prog = "<unset>";
	33
	34	void set_prog(const char *p)
	35	{ const char *q = strrchr(p, '/'); prog = q ? q + 1 : p; }
	36
	37	void vmoan(const char *fmt, va_list ap)
7ea9ce2b	38	{ vmoan_syserr(0, fmt, ap); }
dc53ebfa	39
7ea9ce2b	40	void vmoan_syserr(int err, const char *fmt, va_list ap)
dc53ebfa	41	{
7ea9ce2b MW	42	fprintf(stderr, "%s: ", prog);
	43	vfprintf(stderr, fmt, ap);
	44	if (err) fprintf(stderr, ": %s", strerror(errno));
dc53ebfa MW	45	fputc('\n', stderr);
	46	}
	47
7ea9ce2b MW	48	void moan(const char *fmt, ...)
7ea9ce2b MW	49	{ va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); }
dc53ebfa	50
7ea9ce2b MW	51	void moan_syserr(int err, const char *fmt, ...)
	52	{ va_list ap; va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap); }
	53
	54	void bail(const char *fmt, ...)
	55	{ va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); exit(2); }
dc53ebfa	56
dc53ebfa MW	57	void bail_syserr(int err, const char *fmt, ...)
	58	{
	59	va_list ap;
	60
7ea9ce2b	61	va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap);
dc53ebfa MW	62	exit(2);
	63	}
	64
be15bd14 MW	65	/----- Parsing utilities -------------------------------------------------/
be15bd14 MW	66
f82e4cd7 MW	67	double parse_float(const char **p_inout, unsigned f,
	68	double min, double max, const char *what)
	69	{
	70	const char *p;
	71	char *q;
	72	double x;
	73	int err;
	74
	75	err = errno; errno = 0;
	76	p = *p_inout;
	77	x = strtod(p, &q);
	78	if (errno \|\| x < min \|\| x > max \|\| (!(f&PNF_JUNK) && *q))
	79	bail("bad %s `%s'", what, p);
	80	*p_inout = q; errno = err;
	81	return (x);
	82	}
	83
	84	long parse_int(const char **p_inout, unsigned f,
	85	long min, long max, const char *what)
	86	{
	87	const char *p;
	88	char *q;
	89	long x;
	90	int err;
	91
	92	err = errno; errno = 0;
	93	p = *p_inout;
	94	x = strtoul(p, &q, 0);
	95	if (errno \|\| x < min \|\| x > max \|\| (!(f&PNF_JUNK) && *q))
	96	bail("bad %s `%s'", what, p);
	97	*p_inout = q; errno = err;
	98	return (x);
	99	}
	100
c62cd11a MW	101	/----- Resizing buffers and arrays ---------------------------------------/
	102
	103	void buf__grow(struct buf *b)
	104	{
	105	b->sz = b->sz ? 2*b->sz : 32;
	106	b->p = realloc(b->p, b->sz);
	107	if (!b->p) bail("out of memory allocating %zu bytes", b->sz);
	108	}
42c936a1 MW	109
	110	void vec__grow(void p, size_t esz, size_t *sz_inout)
	111	{
	112	size_t sz = *sz_inout, want;
	113
	114	sz = sz ? 2*sz : 32;
	115	want = sz*esz;
	116	p = realloc(p, want);
	117	if (!p) bail("out of memory allocating %zu bytes", want);
	118	*sz_inout = sz; return (p);
	119	}
	120
be15bd14 MW	121	/----- System utilities --------------------------------------------------/
be15bd14 MW	122
dc53ebfa MW	123	void sit(double t)
	124	{
	125	struct timeval tv;
	126	double whole = floor(t);
	127
	128	if (t) {
	129	tv.tv_sec = whole; tv.tv_usec = floor((t - whole)*1.0e6) + 1;
	130	if (select(0, 0, 0, 0, &tv) < 0) bail_syserr(errno, "failed to sleep");
	131	}
	132	}
	133
cd997467 MW	134	double tvdiff(const struct timeval tv_lo, const struct timeval tv_hi)
	135	{
	136	return ((tv_hi->tv_sec - tv_lo->tv_sec) +
	137	(tv_hi->tv_usec - tv_lo->tv_usec)/1.0e6);
	138	}
	139
d0a95de5 MW	140	int read_line(FILE fp, struct buf b)
	141	{
	142	int ch;
	143
	144	ch = getc(fp);
	145	if (ch == EOF)
	146	return (-1);
	147	else if (ch != '\n')
	148	do { buf_putc(b, ch); ch = getc(fp); } while (ch != EOF && ch != '\n');
	149	buf_putz(b);
	150	return (0);
	151	}
	152
00a5be1d MW	153	void carefully_write(int fd, const void *buf, size_t sz)
	154	{
	155	const unsigned char *p = buf;
	156	ssize_t n;
	157
	158	if (fd < 0) return;
	159	while (sz) {
	160	n = write(fd, p, sz);
	161	if (n < 0) {
	162	if (errno == EINTR) continue;
	163	bail_syserr(errno, "failed to write to output file");
	164	}
	165	if (!n) bail("unexpected short write to output file");
	166	p += n; sz -= n;
	167	}
	168	}
	169
	170	void open_file_on_demand(const char file, FILE fp_inout, const char what)
	171	{
	172	FILE *fp;
	173
	174	if (!*fp_inout) {
	175	fp = fopen(file, "w");
	176	if (!fp) bail_syserr(errno, "failed to open %s file `%s'", what, file);
	177	fprintf(fp, "## %s\n\n", what);
	178	*fp_inout = fp;
	179	}
	180	}
	181
	182	void check_write(FILE fp, const char what)
	183	{
	184	fflush(fp);
	185	if (ferror(fp)) bail_syserr(errno, "error writing %s file", what);
	186	}
	187
	188	void carefully_fclose(FILE fp, const char what)
	189	{
	190	if (fp && (ferror(fp) \|\| fclose(fp)))
	191	bail_syserr(errno, "error writing %s file", what);
	192	}
	193
4bd4876f MW	194	off_t device_size(int fd, const char file, int blksz_out)
	195	{
	196	struct stat st;
	197	uint64_t volsz;
	198
	199	if (fstat(fd, &st))
	200	bail_syserr(errno, "failed to obtain status for `%s'", file);
	201	if (S_ISREG(st.st_mode))
	202	volsz = st.st_size;
	203	else if (S_ISBLK(st.st_mode)) {
	204	if (ioctl(fd, BLKGETSIZE64, &volsz))
	205	bail_syserr(errno, "failed to get volume size for `%s'", file);
	206	if (ioctl(fd, BLKSSZGET, blksz_out))
	207	bail_syserr(errno, "failed to get block size for `%s'", file);
	208	} else
	209	bail("can't read size for `%s': expected file or block device", file);
	210	return ((off_t)volsz);
	211	}
	212
be15bd14 MW	213	/----- Progress utilities ------------------------------------------------/
be15bd14 MW	214
dc53ebfa MW	215	struct progress_state progress = PROGRESS_STATE_INIT;
	216	static struct banner_progress_item banner_progress;
	217
	218	static void render_banner_progress(struct progress_item *item,
	219	struct progress_render_state *render)
	220	{
	221	struct banner_progress_item bi = (struct banner_progress_item )item;
	222
	223	progress_putleft(render, " %s", bi->msg);
	224	progress_shownotice(render, 4, 7);
	225	}
	226
	227	void show_banner(const char *msg)
	228	{
	229	banner_progress._base.render = render_banner_progress;
	230	progress_additem(&progress, &banner_progress._base);
	231	banner_progress.msg = msg;
	232	progress_update(&progress);
	233	}
	234
	235	void hide_banner(void)
	236	{
	237	if (!progress_removeitem(&progress, &banner_progress._base))
	238	progress_update(&progress);
	239	}
	240
be15bd14 MW	241	/----- DVD utilities -----------------------------------------------------/
be15bd14 MW	242
dc53ebfa MW	243	#ifdef notdef
	244	static void logfn(void *p, dvd_logger_level_t lev,
	245	const char *fmt, va_list ap)
	246	{
	247	switch (lev) {
	248	case DVD_LOGGER_LEVEL_ERROR:
	249	fprintf("%s (libdvdread error): ", prog);
	250	break;
	251	case DVD_LOGGER_LEVEL_WARN:
	252	fprintf("%s (libdvdread warning): ", prog);
	253	break;
	254	default:
	255	return;
	256	}
	257	vfprintf(stderr, fmt, ap);
	258	fputc('\n', stderr);
	259	}
	260	static const dvd_logger_cb logger = { logfn };
	261	#endif
	262
972381af MW	263	void open_dvd(const char *device, int mode,
972381af MW	264	int fd_out, dvd_reader_t *dvd_out)
dc53ebfa MW	265	{
	266	int fd;
	267	dvd_reader_t *dvd;
	268	int bannerp = 0;
	269
	270	for (;;) {
972381af	271	fd = open(device, mode);
dc53ebfa MW	272	if (fd >= 0 \|\| errno != ENOMEDIUM) break;
	273	if (!bannerp) {
	274	show_banner("Waiting for disc to be inserted...");
	275	bannerp = 1;
	276	}
	277	sit(0.2);
	278	}
	279	if (bannerp) hide_banner();
	280	if (fd < 0) bail_syserr(errno, "failed to open device `%s'", device);
	281	if (dvd_out) {
	282	#ifdef notdef
	283	dvd = DVDOpen2(0, &logger, device);
	284	#else
	285	dvd = DVDOpen(device);
	286	#endif
	287	if (!dvd) bail("failed to open DVD on `%s'", device);
	288	*dvd_out = dvd;
	289	}
	290	if (fd_out) *fd_out = fd;
	291	else close(fd);
	292	}
1b77f6d3 MW	293
	294	void store_filename(char *buf, ident id)
	295	{
	296	switch (id_kind(id)) {
	297	case RAW:
	298	sprintf(buf, "#<raw device>");
	299	break;
	300	case IFO:
	301	if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.IFO");
	302	else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.IFO", id_title(id));
	303	break;
	304	case BUP:
	305	if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.BUP");
	306	else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.BUP", id_title(id));
	307	break;
	308	case VOB:
	309	if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.VOB");
	310	else
	311	sprintf(buf, "/VIDEO_TS/VTS_%02u_%u.VOB", id_title(id), id_part(id));
	312	break;
	313	default:
	314	abort();
	315	}
	316	}
	317
	318	static char copy_string(char p, const char *q)
	319	{
	320	while (q) p++ = *q++;
	321	*p = 0; return (p);
	322	}
	323
	324	static char copy_hex(char p, const unsigned char *q, size_t sz)
	325	{
	326	while (sz) {
	327	sprintf(p, "%02x", *q);
	328	p += 2; q++; sz--;
	329	}
	330	return (p);
	331	}
	332
	333	int dvd_id(char p, dvd_reader_t dvd, unsigned f, const char *file)
	334	{
	335	char volid[33];
	336	unsigned char volsetid[16], discid[16];
	337	int rc;
	338	size_t n;
	339
	340	rc = DVDUDFVolumeInfo(dvd,
	341	volid, sizeof(volid),
	342	volsetid, sizeof(volsetid));
	343	if (!rc) {
	344	p = copy_string(p, volid);
	345	*p++ = '-';
	346	for (n = sizeof(volsetid); n && !volsetid[n - 1]; n--);
	347	p = copy_hex(p, volsetid, n);
	348	} else if (f&DIF_MUSTVOLINF) {
	349	if (file) moan("failed to read volume info for `%s'", file);
	350	else moan("failed to read volume info");
	351	return (-1);
	352	} else
	353	p = copy_string(p, "<error reading volume info>");
	354
	355	*p++ = ':';
	356	rc = DVDDiscID(dvd, discid);
357	if (!rc)
358	p = copy_hex(p, discid, sizeof(discid));
359	else if (f&DIF_MUSTIFOHASH) {
360	if (file) moan("failed to determine disc id of `%s'", file);
361	else moan("failed to determine disc id");
362	return (-1);
363	} else
364	p = copy_string(p, "<error reading disc-id>");
365
366	return (0);
367	}
be15bd14 MW	368
be15bd14 MW	369	/----- That's all, folks -------------------------------------------------/