开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
cdrecord.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：61k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

cdrecord.c：源码内容
  1. /* @(#)cdrecord.c 1.94 00/01/28 Copyright 1995-2000 J. Schilling */
  2. #ifndef lint
  3. static char sccsid[] =
  4. "@(#)cdrecord.c 1.94 00/01/28 Copyright 1995-2000 J. Schilling";
  5. #endif
  6. /*
  7.  * Record data on a CD/CVD-Recorder
  8.  *
  9.  * Copyright (c) 1995-2000 J. Schilling
  10.  */
  11. /*
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2, or (at your option)
  15.  * any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; see the file COPYING.  If not, write to
  24.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  */
  27. #include <mconfig.h>
  28. #include <stdio.h>
  29. #include <standard.h>
  30. #include <stdxlib.h>
  31. #include <fctldefs.h>
  32. #include <errno.h>
  33. #include <sys/types.h>
  34. #include <sys/time.h>
  35. #ifdef HAVE_SYS_RESOURCE_H
  36. #include <sys/resource.h> /* for rlimit */
  37. #endif
  38. #include <sys/stat.h>
  39. #include <statdefs.h>
  40. #include <unixstd.h>
  41. #ifdef HAVE_SYS_MMAN_H
  42. #include <sys/mman.h>
  43. #endif
  44. #include <strdefs.h>
  45. #include <utypes.h>
  46. #include <intcvt.h>
  47. #include <signal.h>
  49. #include <scg/scsireg.h> /* XXX wegen SC_NOT_READY */
  50. #include <scg/scsitransp.h>
  51. #include <scg/scgcmd.h> /* XXX fuer read_buffer */
  52. #include "scsi_scan.h"
  54. #include "auheader.h"
  55. #include "cdrecord.h"
  57. char cdr_version[] = "1.8";
  59. /*
  60.  * Map toc/track types into names.
  61.  */
  62. char *toc2name[] = {
  63. "CD-DA",
  64. "CD-ROM",
  65. "CD-ROM XA mode 1",
  66. "CD-ROM XA mode 2",
  67. "CD-I",
  68. "Illegal toc type 5",
  69. "Illegal toc type 6",
  70. "Illegal toc type 7",
  71. };
  73. /*
  74.  * Map sector types into names.
  75.  */
  76. char *st2name[] = {
  77. "Illegal sector type 0",
  78. "CD-ROM mode 1",
  79. "CD-ROM mode 2",
  80. "Illegal sector type 3",
  81. "CD-DA without preemphasis",
  82. "CD-DA with preemphasis",
  83. "Illegal sector type 6",
  84. "Illegal sector type 7",
  85. };
  87. /*
  88.  * Map data block types into names.
  89.  */
  90. char *db2name[] = {
  91. "Raw (audio)",
  92. "Raw (audio) with P/Q sub channel",
  93. "Raw (audio) with P/W sub channel",
  94. "Raw (audio) with P/W raw sub channel",
  95. "Reserved mode 4",
  96. "Reserved mode 5",
  97. "Reserved mode 6",
  98. "Vendor unique mode 7",
  99. "CD-ROM mode 1",
  100. "CD-ROM mode 2",
  101. "CD-ROM XA mode 1",
  102. "CD-ROM XA mode 2 form 1",
  103. "CD-ROM XA mode 2 form 2",
  104. "CD-ROM XA mode 2 form 1/2/mix",
  105. "Reserved mode 14",
  106. "Vendor unique mode 15",
  107. };
  109. int debug; /* print debug messages */
  110. LOCAL int scsi_verbose; /* SCSI verbose flag */
  111. int lverbose; /* local verbose flag */
  113. /*
  114.  * NOTICE: You should not make BUF_SIZE more than
  115.  * the buffer size of the CD-Recorder.
  116.  *
  117.  * Do not set BUF_SIZE to be more than 126 KBytes
  118.  * if you are running cdrecord on a sun4c machine.
  119.  *
  120.  * WARNING: Philips CDD 521 dies if BUF_SIZE is to big.
  121.  */
  122. /*#define BUF_SIZE (126*1024)*/
  123. /*#define BUF_SIZE (100*1024)*/
  124. #define BUF_SIZE (63*1024)
  125. /*#define BUF_SIZE (56*1024)*/
  127. char *buf; /* The transfer buffer */
  128. long bufsize; /* The size of the transfer buffer */
  129. int data_secs_per_tr; /* # of data secs per transfer */
  130. int audio_secs_per_tr; /* # of audio secs per transfer */
  132. BOOL isgui;
  133. int didintr;
  135. struct timeval starttime;
  136. struct timeval stoptime;
  137. struct timeval fixtime;
  139. static long fs = -1L; /* fifo (ring buffer) size */
  141. EXPORT int  main __PR((int ac, char **av));
  142. LOCAL void usage __PR((int));
  143. LOCAL void blusage __PR((int));
  144. LOCAL void intr __PR((int sig));
  145. LOCAL void intfifo __PR((int sig));
  146. LOCAL void exscsi __PR((int excode, void *arg));
  147. LOCAL void excdr __PR((int excode, void *arg));
  148. EXPORT int read_buf __PR((int f, char *bp, int size));
  149. EXPORT int get_buf __PR((int f, char **bpp, int size));
  150. LOCAL int write_track_data __PR((SCSI *scgp, cdr_t *, int , track_t *));
  151. EXPORT int pad_track __PR((SCSI *scgp, cdr_t *dp, int track, track_t *trackp,
  152.      long startsec, long amt,
  153.      BOOL dolast, long *bytesp));
  154. EXPORT int write_buf __PR((SCSI *scgp, cdr_t *dp, int track, track_t *trackp,
  155.      char *bp, long startsec, long amt, int secsize,
  156.      BOOL dolast, long *bytesp));
  157. LOCAL void printdata __PR((int, track_t *));
  158. LOCAL void printaudio __PR((int, track_t *));
  159. LOCAL void checkfile __PR((int, track_t *));
  160. LOCAL int checkfiles __PR((int, track_t *));
  161. LOCAL void setpregaps __PR((int, track_t *));
  162. LOCAL long checktsize __PR((int, track_t *));
  163. LOCAL void checksize __PR((track_t *));
  164. LOCAL BOOL checkdsize __PR((SCSI *scgp, cdr_t *dp, dstat_t *dsp, long tsize));
  165. LOCAL void raise_fdlim __PR((void));
  166. LOCAL void gargs __PR((int, char **, int *, track_t *, char **,
  167. int *, cdr_t **,
  168. int *, long *, int *, int *));
  169. LOCAL void set_trsizes __PR((cdr_t *, int, track_t *));
  170. EXPORT void load_media __PR((SCSI *scgp, cdr_t *, BOOL));
  171. EXPORT void unload_media __PR((SCSI *scgp, cdr_t *, int));
  172. EXPORT void set_secsize __PR((SCSI *scgp, int secsize));
  173. LOCAL void check_recovery __PR((SCSI *scgp, cdr_t *, int));
  174. void audioread __PR((SCSI *scgp, cdr_t *, int));
  175. LOCAL void print_msinfo __PR((SCSI *scgp, cdr_t *));
  176. LOCAL void print_toc __PR((SCSI *scgp, cdr_t *));
  177. LOCAL void print_track __PR((int, long, struct msf *, int, int, int));
  178. LOCAL void prtimediff __PR((const char *fmt,
  179. struct timeval *start,
  180. struct timeval *stop));
  181. #if !defined(HAVE_SYS_PRIOCNTL_H)
  182. LOCAL int rt_raisepri __PR((int));
  183. #endif
  184. EXPORT void raisepri __PR((int));
  185. LOCAL void checkgui __PR((void));
  186. LOCAL char * astoll __PR((const char *s, Llong *ll));
  187. LOCAL Llong number __PR((char* arg, int* retp));
  188. EXPORT int getnum __PR((char* arg, long* valp));
  189. EXPORT int getllnum __PR((char *arg, Llong* lvalp));
  190. LOCAL int getbltype __PR((char* optstr, long *typep));
  192. struct exargs {
  193. SCSI *scgp;
  194. cdr_t *dp;
  195. int old_secsize;
  196. int flags;
  197. int exflags;
  198. } exargs;
  200. EXPORT int 
  201. main(ac, av)
  202. int ac;
  203. char *av[];
  204. {
  205. char *dev = NULL;
  206. int timeout = 40; /* Set default timeout to 40s CW-7502 is slow*/
  207. int speed = 1;
  208. long flags = 0L;
  209. int toctype = -1;
  210. int blanktype = 0;
  211. int i;
  212. int tracks = 0;
  213. int trackno;
  214. long tsize;
  215. track_t track[MAX_TRACK+2]; /* Max tracks + track 0 + track AA */
  216. cdr_t *dp = (cdr_t *)0;
  217. dstat_t ds;
  218. long startsec = 0L;
  219. int errs = 0;
  220. SCSI *scgp;
  221. char errstr[80];
  223. #ifdef __EMX__ 
  224. /* This gives wildcard expansion with Non-Posix shells with EMX */ 
  225. _wildcard(&ac, &av); 
  226. #endif 
  227. save_args(ac, av);
  229. fillbytes(track, sizeof(track), '');
  230. raise_fdlim();
  231. gargs(ac, av, &tracks, track, &dev, &timeout, &dp, &speed, &flags,
  232. &toctype, &blanktype);
  233. if (toctype < 0)
  234. comerrno(EX_BAD, "Internal error: Bad TOC type.n");
  236. /*
  237.  * Warning: you are not allowed to modify or to remove this
  238.  * version printing code!
  239.  */
  240. #ifdef DRV_DVD
  241. i = set_cdrcmds("mmc_dvd", (cdr_t **)NULL);
  242. #endif
  243. if ((flags & F_MSINFO) == 0 || lverbose || flags & F_VERSION)
  244. printf("Cdrecord%s %s (%s-%s-%s) Copyright (C) 1995-2000 J鰎g Schillingn",
  245. #ifdef DRV_DVD
  246. i?"-ProDVD":"",
  247. #else
  248. "",
  249. #endif
  250. cdr_version,
  251. HOST_CPU, HOST_VENDOR, HOST_OS);
  252. if (flags & F_VERSION)
  253. exit(0);
  255. checkgui();
  257. if (debug || lverbose) {
  258. printf("TOC Type: %d = %sn",
  259. toctype, toc2name[toctype & TOC_MASK]);
  260. }
  262. if ((flags & (F_MSINFO|F_TOC|F_PRATIP|F_FIX|F_VERSION|F_CHECKDRIVE|F_INQUIRY|F_SCANBUS|F_RESET)) == 0) {
  263. /*
  264.  * Try to lock us im memory (will only work for root)
  265.  * but you need access to root anyway to use /dev/scg?
  266.  */
  267. #if defined(HAVE_MLOCKALL) || defined(_POSIX_MEMLOCK)
  268. if (mlockall(MCL_CURRENT|MCL_FUTURE) < 0) {
  269. errmsg("WARNING: Cannot do mlockall(2).n");
  270. errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.n");
  271. }
  272. #endif
  274. raisepri(0); /* max priority */
  275. init_fifo(fs);
  276. }
  278. if ((scgp = open_scsi(dev, errstr, sizeof(errstr),
  279. debug, (flags & F_MSINFO) == 0 || lverbose)) == (SCSI *)0) {
  280. errmsg("%s%sCannot open SCSI driver.n", errstr, errstr[0]?". ":"");
  281. comerrno(EX_BAD, "For possible targets try 'cdrecord -scanbus'. Make sure you are root.n");
  282. }
  283. scsi_settimeout(scgp, timeout);
  284. scgp->verbose = scsi_verbose;
  285. scgp->debug = debug;
  286. scgp->cap->c_bsize = 2048;
  288. if ((flags & F_MSINFO) == 0 || lverbose) {
  289. char *vers;
  290. char *auth;
  292. /*
  293.  * Warning: you are not allowed to modify or to remove this 
  294.  * version checking code!
  295.  */
  296. vers = scg_version(0, SCG_VERSION);
  297. auth = scg_version(0, SCG_AUTHOR);
  298. printf("Using libscg version '%s-%s'n", auth, vers);
  299. if (auth == 0 || strcmp("schily", auth) != 0) {
  300. errmsgno(EX_BAD,
  301. "Warning: using inofficial version of libscg (%s-%s '%s').n",
  302. auth, vers, scg_version(0, SCG_SCCS_ID));
  303. }
  305. vers = scg_version(scgp, SCG_VERSION);
  306. auth = scg_version(scgp, SCG_AUTHOR);
  307. if (lverbose > 1)
  308. error("Using libscg transport code version '%s-%s'n", auth, vers);
  309. if (auth == 0 || strcmp("schily", auth) != 0) {
  310. errmsgno(EX_BAD,
  311. "Warning: using inofficial libscg transport code version (%s-%s '%s').n",
  312. auth, vers, scg_version(scgp, SCG_SCCS_ID));
  313. }
  314. }
  316. bufsize = scsi_bufsize(scgp, BUF_SIZE);
  317. if ((buf = scsi_getbuf(scgp, bufsize)) == NULL)
  318. comerr("Cannot get SCSI I/O buffer.n");
  320. if ((flags & F_SCANBUS) != 0) {
  321. select_target(scgp);
  322. exit(0);
  323. }
  324. if ((flags & F_RESET) != 0) {
  325. scsireset(scgp);
  326. exit(0);
  327. }
  328. /*
  329.  * First try to check which type of SCSI device we
  330.  * have.
  331.  */
  332. if (debug || lverbose)
  333. printf("atapi: %dn", scsi_isatapi(scgp));
  334. scgp->silent++;
  335. test_unit_ready(scgp); /* eat up unit attention */
  336. scgp->silent--;
  337. if (!do_inquiry(scgp, (flags & F_MSINFO) == 0 || lverbose)) {
  338. errmsgno(EX_BAD, "Cannot do inquiry for CD/DVD-Recorder.n");
  339. if (unit_ready(scgp))
  340. errmsgno(EX_BAD, "The unit seems to be hung and needs power cycling.n");
  341. exit(EX_BAD);
  342. }
  344. if ((flags & F_PRCAP) != 0) {
  345. print_capabilities(scgp);
  346. exit(0);
  347. }
  348. if ((flags & F_INQUIRY) != 0)
  349. exit(0);
  351. if (dp == (cdr_t *)NULL) { /* No driver= option specified */
  352. dp = get_cdrcmds(scgp);
  353. } else if (!is_unknown_dev(scgp) && dp != get_cdrcmds(scgp)) {
  354. errmsgno(EX_BAD, "WARNING: Trying to use other driver on known device.n");
  355. }
  357. if (!is_cddrive(scgp))
  358. comerrno(EX_BAD, "Sorry, no CD/DVD-Drive found on this target.n");
  359. if (dp == (cdr_t *)0)
  360. comerrno(EX_BAD, "Sorry, no supported CD/DVD-Recorder found on this target.n");
  362. if (((flags & (F_MSINFO|F_TOC|F_LOAD|F_EJECT)) == 0 || tracks > 0) &&
  363. (dp->cdr_flags & CDR_ISREADER) != 0) {
  364. comerrno(EX_BAD,
  365. "Sorry, no CD/DVD-Recorder or unsupported CD/DVD-Recorder found on this target.n");
  366. }
  368. if ((*dp->cdr_attach)(scgp, dp) != 0)
  369. comerrno(EX_BAD, "Cannot attach driver for CD/DVD-Recorder.n");
  371. exargs.scgp    = scgp;
  372. exargs.dp    = dp;
  373. exargs.old_secsize = -1;
  374. exargs.flags    = flags;
  376. if ((flags & F_MSINFO) == 0 || lverbose) {
  377. printf("Using %s (%s).n", dp->cdr_drtext, dp->cdr_drname);
  378. printf("Driver flags   : ");
  379. if ((dp->cdr_flags & CDR_SWABAUDIO) != 0)
  380. printf("SWABAUDIO");
  381. printf("n");
  382. }
  383. scgp->silent++;
  384. if ((debug || lverbose)) {
  385. tsize = -1;
  386. if ((*dp->cdr_buffer_cap)(scgp, &tsize, (long *)0) < 0 || tsize <= 0) {
  387. if (read_buffer(scgp, buf, 4, 0) >= 0)
  388. tsize = a_to_u_4_byte(buf);
  389. }
  390. if (tsize > 0) {
  391. printf("Drive buf size : %lu = %lu KBn",
  392. tsize, tsize >> 10);
  393. }
  394. }
  395. scgp->silent--;
  397. if (tracks > 0 && (debug || lverbose))
  398. printf("FIFO size      : %lu = %lu KBn", fs, fs >> 10);
  400. if ((flags & F_CHECKDRIVE) != 0)
  401. exit(0);
  403. if (tracks == 0 && (flags & (F_FIX|F_BLANK)) == 0 && (flags & F_EJECT) != 0) {
  404. /*
  405.  * Do not check if the unit is ready here to allow to open
  406.  * an empty unit too.
  407.  */
  408. unload_media(scgp, dp, flags);
  409. exit(0);
  410. }
  412. flush();
  413. if (tracks > 1)
  414. sleep(2); /* Let the user watch the inquiry messages */
  416. set_trsizes(dp, tracks, track);
  417. setpregaps(tracks, track);
  418. checkfiles(tracks, track);
  419. tsize = checktsize(tracks, track);
  420. do_cue(tracks, track, 0);
  422. /*
  423.  * Is this the right place to do this ?
  424.  */
  425. check_recovery(scgp, dp, flags);
  427. if ((flags & F_FORCE) == 0)
  428. load_media(scgp, dp, TRUE);
  430. if ((flags & F_LOAD) != 0) {
  431. scgp->silent++; /* silently      */
  432. scsi_prevent_removal(scgp, 0); /* allow manual open */
  433. scgp->silent--; /* if load failed... */
  434. exit(0);
  435. }
  436. exargs.old_secsize = sense_secsize(scgp, 1);
  437. if (exargs.old_secsize < 0)
  438. exargs.old_secsize = sense_secsize(scgp, 0);
  439. on_comerr(exscsi, &exargs);
  441. if (lverbose)
  442. printf("Current Secsize: %dn", exargs.old_secsize);
  444. if (exargs.old_secsize > 0 && exargs.old_secsize != 2048) {
  445. /*
  446.  * Some drives (e.g. Plextor) don't like to write correctly
  447.  * in DAO mode if the sector size is set to 512 bytes.
  448.  * In addition, cdrecord -msinfo will not work properly
  449.  * if the sector size is not 2048 bytes.
  450.  */
  451. set_secsize(scgp, 2048);
  452. }
  454. /*audioread(dp, flags);*/
  455. /*unload_media(scgp, dp, flags);*/
  456. /*return 0;*/
  457. fillbytes(&ds, sizeof(ds), '');
  458. if (flags & F_WRITE)
  459. ds.ds_cdrflags = RF_WRITE;
  460. if (flags & F_PRATIP) {
  461. lverbose++; /* XXX Hack */
  462. }
  463. if ((*dp->cdr_getdisktype)(scgp, dp, &ds) < 0) {
  464. errmsgno(EX_BAD, "Cannot get disk type.n");
  465. exscsi(EX_BAD, &exargs);
  466. if ((flags & F_FORCE) == 0)
  467. exit(EX_BAD);
  468. }
  469. if (flags & F_PRATIP) {
  470. lverbose--; /* XXX Hack */
  471. exscsi(0, &exargs);
  472. exit(0);
  473. }
  474. /*
  475.  * The next actions should depend on the disk type.
  476.  */
  478. /*
  479.  * Dirty hack!
  480.  * At least MMC drives will not return the next writable
  481.  * address we expect when the drive's write mode is set
  482.  * tp DAO/SAO. We need this address for mkisofs and thus
  483.  * it must be the first user accessible sector and not the
  484.  * first sector of the pregap. Set_speed_dummy() witha a
  485.  * 'speedp' f 0 sets the write mode to TAO on MMC drives.
  486.  *
  487.  * We set TAO unconditionally to make checkdsize() work
  488.  * currectly in DAO mode too.
  489.  */
  490. scgp->silent++;
  491. (*dp->cdr_set_speed_dummy)(scgp, 0, TRUE);
  492. scgp->silent--;
  494. if (flags & F_MSINFO) {
  495. print_msinfo(scgp, dp);
  496. exscsi(0, &exargs);
  497. exit(0);
  498. }
  499. if (flags & F_TOC) {
  500. print_toc(scgp, dp);
  501. exscsi(0, &exargs);
  502. exit(0);
  503. }
  505. #ifdef XXX
  506. if ((*dp->cdr_check_session)() < 0) {
  507. exscsi(EX_BAD, &exargs);
  508. exit(EX_BAD);
  509. }
  510. #endif
  511. if (tsize == 0) {
  512. if (tracks > 0) {
  513. errmsgno(EX_BAD,
  514. "WARNING: Track size unknown. Data may not fit on disk.n");
  515. }
  516. } else if (!checkdsize(scgp, dp, &ds, tsize) && (flags & (F_IGNSIZE|F_FORCE)) == 0) {
  517. exscsi(EX_BAD, &exargs);
  518. exit(EX_BAD);
  519. }
  520. if (tracks > 0 && fs > 0l) {
  521. /*
  522.  * Start the extra process needed for improved buffering.
  523.  */
  524. if (!init_faio(tracks, track, bufsize))
  525. fs = 0L;
  526. else
  527. on_comerr(excdr, &exargs);
  528. }
  529. if ((*dp->cdr_set_speed_dummy)(scgp, &speed, flags & F_DUMMY) < 0) {
  530. errmsgno(EX_BAD, "Cannot set speed/dummy.n");
  531. excdr(EX_BAD, &exargs);
  532. exit(EX_BAD);
  533. }
  534. if ((flags & (F_BLANK|F_FORCE)) == (F_BLANK|F_FORCE)) {
  535. wait_unit_ready(scgp, 120);
  536. scsi_blank(scgp, 0L, blanktype);
  537. excdr(0, &exargs);
  538. exit(0);
  539. }
  540. /*
  541.  * Last chance to quit!
  542.  */
  543. printf("Starting to write CD/DVD at speed %d in %s mode for %s session.n",
  544. speed,
  545. (flags & F_DUMMY) ? "dummy" : "write",
  546. (flags & F_MULTI) ? "multi" : "single");
  547. printf("Last chance to quit, starting %s write in 9 seconds.",
  548. (flags & F_DUMMY)?"dummy":"real");
  549. flush();
  550. signal(SIGINT, intr);
  551. for (i=9; --i > 0;) {
  552. sleep(1);
  553. if (didintr) {
  554. printf("n");
  555. goto restore_it;
  556. }
  557. printf("bbbbbbbbbb%d seconds.", i);
  558. flush();
  559. }
  560. signal(SIGINT, SIG_DFL);
  561. signal(SIGINT, intfifo);
  562. signal(SIGTERM, intfifo);
  563. printf("n");
  564. if (tracks > 0 && fs > 0l) {
  565. /*
  566.  * Wait for the read-buffer to become full.
  567.  * This should be take no extra time if the input is a file.
  568.  * If the input is a pipe (e.g. mkisofs) this can take a
  569.  * while. If mkisofs dumps core before it starts writing,
  570.  * we abort before the writing process started.
  571.  */
  572. if (!await_faio()) {
  573. errmsgno(EX_BAD, "Input buffer error, aborting.n");
  574. excdr(EX_BAD, &exargs);
  575. exit(EX_BAD);
  576. }
  577. }
  578. if (gettimeofday(&starttime, (struct timezone *)0) < 0)
  579. errmsg("Cannot get start timen");
  581. /*
  582.  * Blank the media if we were requested to do so
  583.  */
  584. if (flags & F_BLANK) {
  585. if ((*dp->cdr_blank)(scgp, 0L, blanktype) < 0) {
  586. errmsgno(EX_BAD, "Cannot blank disk, aborting.n");
  587. excdr(EX_BAD, &exargs);
  588. exit(EX_BAD);
  589. }
  590. if (gettimeofday(&fixtime, (struct timezone *)0) < 0)
  591. errmsg("Cannot get blank timen");
  592. if (lverbose)
  593. prtimediff("Blanking time: ", &starttime, &fixtime);
  595. if (!wait_unit_ready(scgp, 60) || tracks == 0) {
  596. excdr(0, &exargs);
  597. exit(0);
  598. }
  599. /*
  600.  * Reset start time so we will not see blanking time and
  601.  * writing time counted together.
  602.  */
  603. if (gettimeofday(&starttime, (struct timezone *)0) < 0)
  604. errmsg("Cannot get start timen");
  605. }
  606. /*
  607.  * Get the number of the next recordable track.
  608.  */
  609. scgp->silent++;
  610. if (read_tochdr(scgp, dp, NULL, &trackno) < 0) {
  611. trackno = 0;
  612. }
  613. scgp->silent--;
  614. for (i = 1; i <= tracks; i++) {
  615. track[i].trackno = i + trackno;
  616. }
  617. trackno++;
  618. track[0].trackno = trackno; /* XXX Hack for TEAC fixate */
  620. /*
  621.  * Now we actually start writing to the CD/DVD.
  622.  * XXX Check total size of the tracks and remaining size of disk.
  623.  */
  624. if ((*dp->cdr_open_session)(scgp, tracks, track, toctype, flags & F_MULTI) < 0) {
  625. errmsgno(EX_BAD, "Cannot open new session.n");
  626. excdr(EX_BAD, &exargs);
  627. exit(EX_BAD);
  628. }
  630. /*
  631.  * As long as open_session() will do nothing but
  632.  * set up parameters, we may leave fix_it here.
  633.  * I case we have to add an open_session() for a drive
  634.  * that wants to do something that modifies the disk
  635.  * We have to think about a new solution.
  636.  */
  637. if (flags & F_FIX)
  638. goto fix_it;
  640. if (flags & F_SAO) {
  641. if (debug || lverbose) {
  642. printf("Sending CUE sheet...n");
  643. flush();
  644. }
  645. if ((*dp->cdr_send_cue)(scgp, tracks, track) < 0) {
  646. errmsgno(EX_BAD, "Cannot send CUE sheet.n");
  647. excdr(EX_BAD, &exargs);
  648. exit(EX_BAD);
  649. }
  650. }
  651. if ((flags & F_SAO)) {
  652. (*dp->cdr_next_wr_address)(scgp, 0, &track[0], &startsec);
  653. if (startsec <= 0 && startsec != -150) {
  654. errmsgno(EX_BAD, "WARNING: Drive returns wrong startsec (%d) using -150n",
  655. startsec);
  656. startsec = -150;
  657. }
  659. if (debug)
  660. printf("SAO startsec: %ldn", startsec);
  662. for (i = 1; i <= tracks; i++) {
  663. track[i].trackstart += startsec +150;
  664. }
  665. #ifdef XXX
  666. if (debug || lverbose)
  667. printf("Writing lead-in...n");
  669. pad_track(scgp, dp, 1, &track[1], -150, 0,
  670. FALSE, 0);
  671. #endif
  672. }
  673. /*
  674.  * Need to set trackno to the real value from
  675.  * the current disk status.
  676.  */
  677. for (i = 1; i <= tracks; i++, trackno++) {
  678. startsec = 0L;
  680. /*
  681.  * trackno is the "real" track number while 'i' is a counter
  682.  * going from 1 to tracks.
  683.  */
  684. if ((*dp->cdr_open_track)(scgp, dp, trackno, &track[i]) < 0) {
  685. errs++;
  686. break;
  687. }
  689. if ((flags & F_SAO) == 0) {
  690. if ((*dp->cdr_next_wr_address)(scgp, trackno, &track[i], &startsec) < 0) {
  691. errs++;
  692. break;
  693. }
  694. track[i].trackstart = startsec;
  695. }
  696. if (debug || lverbose) {
  697. printf("Starting new track at sector: %ldn",
  698. track[i].trackstart);
  699. flush();
  700. }
  701. if (write_track_data(scgp, dp, trackno, &track[i]) < 0) {
  702. errs++;
  703. sleep(5);
  704. request_sense(scgp);
  705. (*dp->cdr_close_track)(scgp, trackno, &track[i]);
  706. break;
  707. }
  708. if ((*dp->cdr_close_track)(scgp, trackno, &track[i]) < 0) {
  709. /*
  710.  * Check for "Dummy blocks added" message first.
  711.  */
  712. if (scsi_sense_key(scgp) != SC_ILLEGAL_REQUEST ||
  713. scsi_sense_code(scgp) != 0xB5) {
  714. errs++;
  715. break;
  716. }
  717. }
  718. }
  719. fix_it:
  720. if (gettimeofday(&stoptime, (struct timezone *)0) < 0)
  721. errmsg("Cannot get stop timen");
  722. if (lverbose)
  723. prtimediff("Writing  time: ", &starttime, &stoptime);
  725. if ((flags & F_NOFIX) == 0) {
  726. if (lverbose) {
  727. printf("Fixating...n");
  728. flush();
  729. }
  730. if ((*dp->cdr_fixate)(scgp, flags & F_MULTI, flags & F_DUMMY,
  731. toctype, tracks, track) < 0)
  732. errs++;
  734. if (gettimeofday(&fixtime, (struct timezone *)0) < 0)
  735. errmsg("Cannot get fix timen");
  736. if (lverbose)
  737. prtimediff("Fixating time: ", &stoptime, &fixtime);
  738. }
  740. restore_it:
  741. /*
  742.  * Try to restore the old sector size and stop FIFO.
  743.  */
  744. excdr(errs?-2:0, &exargs);
  745. exit(errs?-2:0);
  746. return (0);
  747. }
  749. LOCAL void 
  750. usage(excode)
  751. int excode;
  752. {
  753. errmsgno(EX_BAD, "Usage: %s [options] track1...tracknn",
  754. get_progname());
  756. error("Options:n");
  757. error("t-version print version information and exitn");
  758. error("t-v increment general verbose level by onen");
  759. error("t-V increment SCSI command transport verbose level by onen");
  760. error("t-debug print additional debug messagesn");
  761. error("tdev=target SCSI target to use as CD/DVD-Recordern");
  762. error("ttimeout=# set the default SCSI command timeout to #.n");
  763. error("tdriver=name user supplied driver name, use with extreme caren");
  764. error("t-checkdrive check if a driver for the drive is presentn");
  765. error("t-prcap print drive capabilities for MMC compliant drivesn");
  766. error("t-inq do an inquiry for the drive end exitn");
  767. error("t-scanbus scan the SCSI bus end exitn");
  768. error("t-reset reset the SCSI bus with the cdrecorder (if possible)n");
  769. error("t-ignsize ignore the known size of a medium (may cause problems)n");
  770. error("t-useinfo use *.inf files to overwrite audio options.n");
  771. error("tspeed=# set speed of driven");
  772. error("tblank=type blank a CD-RW disc (see blank=help)n");
  773. #ifdef FIFO
  774. error("tfs=# Set fifo size to # (0 to disable, default is %ld MB)n",
  775. DEFAULT_FIFOSIZE/(1024*1024));
  776. #endif
  777. error("t-load load the disk and exit (works only with tray loader)n");
  778. error("t-eject eject the disk after doing the workn");
  779. error("t-dummy do everything with laser turned offn");
  780. error("t-msinfo retrieve multi-session info for mkisofs >= 1.10n");
  781. error("t-toc retrieve and print TOC/PMA datan");
  782. error("t-atip retrieve and print ATIP datan");
  783. error("t-multi generate a TOC that allows multi sessionn");
  784. error("t In this case default track type is CD-ROM XA2n");
  785. error("t-fix fixate a corrupt or unfixated disk (generate a TOC)n");
  786. error("t-nofix do not fixate disk after writing tracksn");
  787. error("t-force force to continue on some errors to allow blanking bad disksn");
  788. error("t-dao Write disk in DAO mode. This option will go away in the future.n");
  789. error("ttsize=# Length of valid data in next trackn");
  790. error("tpadsize=# Amount of padding for next trackn");
  791. error("tpregap=# Amount of pre-gap sectors before next trackn");
  792. error("tdefpregap=# Amount of pre-gap sectors for all but track #1n");
  793. error("tmcn=text Set the media catalog number for this CD to 'text'n");
  794. error("tisrc=text Set the ISRC number for the next track to 'text'n");
  795. error("tindex=list Set the index list for the next track to 'list'n");
  797. error("t-audio Subsequent tracks are CD-DA audio tracksn");
  798. error("t-data Subsequent tracks are CD-ROM data mode 1 (default)n");
  799. error("t-mode2 Subsequent tracks are CD-ROM data mode 2n");
  800. error("t-xa1 Subsequent tracks are CD-ROM XA mode 1n");
  801. error("t-xa2 Subsequent tracks are CD-ROM XA mode 2n");
  802. error("t-cdi Subsequent tracks are CDI tracksn");
  803. error("t-isosize Use iso9660 file system size for next data trackn");
  804. error("t-preemp Audio tracks are mastered with 50/15 祍 preemphasisn");
  805. error("t-nopreemp Audio tracks are mastered with no preemphasis (default)n");
  806. error("t-pad Pad data tracks with %d zeroed sectorsn", PAD_SECS);
  807. error("t Pad audio tracks to a multiple of %d bytesn", AUDIO_SEC_SIZE);
  808. error("t-nopad Do not pad data tracks (default)n");
  809. error("t-swab Audio data source is byte-swapped (little-endian/Intel)n");
  810. error("The type of the first track is used for the toc type.n");
  811. error("Currently only form 1 tracks are supported.n");
  812. exit(excode);
  813. }
  815. LOCAL void
  816. blusage(ret)
  817. int ret;
  818. {
  819. error("Blanking options:n");
  820. error("tallttblank the entire diskn");
  821. error("tdiscttblank the entire diskn");
  822. error("tdiskttblank the entire diskn");
  823. error("tfastttminimally blank the entire disk (PMA, TOC, pregap)n");
  824. error("tminimalttminimally blank the entire disk (PMA, TOC, pregap)n");
  825. error("ttrackttblank a trackn");
  826. error("tunreservetunreserve a trackn");
  827. error("ttrtailttblank a track tailn");
  828. error("tunclosettunclose last sessionn");
  829. error("tsessionttblank last sessionn");
  831. exit(ret);
  832. /* NOTREACHED */
  833. }
  835. LOCAL void
  836. intr(sig)
  837. int sig;
  838. {
  839. sig = 0; /* Fake usage */
  841. signal(SIGINT, intr);
  843. didintr++;
  844. }
  846. LOCAL void
  847. intfifo(sig)
  848. int sig;
  849. {
  850. excdr(sig, NULL);
  851. exit(sig);
  852. }
  854. LOCAL void
  855. exscsi(excode, arg)
  856. int excode;
  857. void *arg;
  858. {
  859. struct exargs *exp = (struct exargs *)arg;
  861. /*
  862.  * Try to restore the old sector size.
  863.  */
  864. if (exp != NULL && exp->exflags == 0) {
  866. set_secsize(exp->scgp, exp->old_secsize);
  867. unload_media(exp->scgp, exp->dp, exp->flags);
  869. exp->exflags++; /* Make sure that it only get called once */
  870. }
  871. }
  873. LOCAL void
  874. excdr(excode, arg)
  875. int excode;
  876. void *arg;
  877. {
  878. exscsi(excode, arg);
  880. #ifdef FIFO
  881. kill_faio();
  882. wait_faio();
  883. if (debug || lverbose)
  884. fifo_stats();
  885. #endif
  886. }
  888. EXPORT int
  889. read_buf(f, bp, size)
  890. int f;
  891. char *bp;
  892. int size;
  893. {
  894. char *p = bp;
  895. int amount = 0;
  896. int n;
  898. do {
  899. do {
  900. n = read(f, p, size-amount);
  901. } while (n < 0 && (errno == EAGAIN || errno == EINTR));
  902. if (n < 0)
  903. return (n);
  904. amount += n;
  905. p += n;
  907. } while (amount < size && n > 0);
  908. return (amount);
  909. }
  911. EXPORT int
  912. get_buf(f, bpp, size)
  913. int f;
  914. char **bpp;
  915. int size;
  916. {
  917. if (fs > 0) {
  918. /* return (faio_read_buf(f, *bpp, size));*/
  919. return (faio_get_buf(f, bpp, size));
  920. } else {
  921. return (read_buf(f, *bpp, size));
  922. }
  923. }
  925. LOCAL int
  926. write_track_data(scgp, dp, track, trackp)
  927. SCSI *scgp;
  928. cdr_t *dp;
  929. int track;
  930. track_t *trackp;
  931. {
  932. int f;
  933. int isaudio;
  934. long startsec;
  935. long bytes_read = 0;
  936. long bytes = 0;
  937. long savbytes = 0;
  938. int count;
  939. long tracksize;
  940. int secsize;
  941. int secspt;
  942. int bytespt;
  943. int bytes_to_read;
  944. long amount;
  945. int pad;
  946. int bswab;
  947. BOOL neednl = FALSE;
  948. BOOL islast = FALSE;
  949. char *bp = buf;
  950. long bsize;
  951. long bfree;
  952. #ifdef BCAP
  953. int per;
  954. int oper = -1;
  955. #endif
  957. scgp->silent++;
  958. if (read_buff_cap(scgp, &bsize, &bfree) < 0)
  959. bsize = -1;
  960. scgp->silent--;
  963. if (is_packet(trackp)) /* XXX Ugly hack for now */
  964. return (write_packet_data(scgp, dp, track, trackp));
  966. f = trackp->f;
  967. isaudio = is_audio(trackp);
  968. tracksize = trackp->tracksize;
  969. startsec = trackp->trackstart;
  971. secsize = trackp->secsize;
  972. secspt = trackp->secspt;
  973. bytespt = secsize * secspt;
  975. pad = !isaudio && is_pad(trackp); /* Pad only data tracks */
  976. bswab = isaudio && is_swab(trackp); /* Swab only audio tracks */
  978. if (debug) {
  979. printf("secsize:%d secspt:%d bytespt:%d audio:%d pad:%dn",
  980. secsize, secspt, bytespt, isaudio, pad);
  981. }
  983. if (lverbose) {
  984. if (tracksize > 0)
  985. printf("rTrack %02d:   0 of %3ld MB written.",
  986.        track, tracksize >> 20);
  987. else
  988. printf("rTrack %02d:   0 MB written.", track);
  989. flush();
  990. neednl = TRUE;
  991. }
  993. do {
  994. bytes_to_read = bytespt;
  995. if (tracksize > 0) {
  996. bytes_to_read = tracksize - bytes_read;
  997. if (bytes_to_read > bytespt)
  998. bytes_to_read = bytespt;
  999. }
  1000. count = get_buf(f, &bp, bytes_to_read);
  1002. if (count < 0)
  1003. comerr("read error on input filen");
  1004. if (count == 0)
  1005. break;
  1006. bytes_read += count;
  1007. if (tracksize >= 0 && bytes_read >= tracksize) {
  1008. count -= bytes_read - tracksize;
  1009. if (trackp->padsize == 0 && (bytes_read/secsize) >= 300)
  1010. islast = TRUE;
  1011. }
  1013. if (bswab)
  1014. swabbytes(bp, count);
  1016. if (count < bytespt) {
  1017. if (debug) {
  1018. printf("nNOTICE: reducing block size for last record.n");
  1019. neednl = FALSE;
  1020. }
  1022. if ((amount = count % secsize) != 0) {
  1023. amount = secsize - amount;
  1024. fillbytes(&bp[count], amount, '');
  1025. count += amount;
  1026. printf("nWARNING: padding up to secsize.n");
  1027. neednl = FALSE;
  1028. }
  1029. bytespt = count;
  1030. secspt = count / secsize;
  1031. if (trackp->padsize == 0 && (bytes_read/secsize) >= 300)
  1032. islast = TRUE;
  1033. }
  1035. amount = (*dp->cdr_write_trackdata)(scgp, bp, startsec, bytespt, secspt, islast);
  1036. if (amount < 0) {
  1037. printf("%swrite track data: error after %ld bytesn",
  1038. neednl?"n":"", bytes);
  1039. return (-1);
  1040. }
  1041. bytes += amount;
  1042. startsec += amount / secsize;
  1044. if (lverbose && (bytes >= (savbytes + 0x100000))) {
  1045. int fper;
  1047. printf("rTrack %02d: %3ld", track, bytes >> 20);
  1048. if (tracksize > 0)
  1049. printf(" of %3ld MB", tracksize >> 20);
  1050. else
  1051. printf(" MB");
  1052. printf(" written");
  1053. fper = fifo_percent(TRUE);
  1054. if (fper >= 0)
  1055. printf(" (fifo %3d%%)", fper);
  1056. printf(".");
  1057. savbytes = (bytes >> 20) << 20;
  1058. flush();
  1059. neednl = TRUE;
  1060. }
  1061. #ifdef BCAP
  1062. if (bsize >= 0) {
  1063. read_buff_cap(scgp, 0, &bfree);
  1064. per = 100*(bsize - bfree) / bsize;
  1065. if (per != oper)
  1066. printf("[%3d] %3d %3dbbbbbbbbbbbbbb",
  1067. per, bsize >> 10, bfree >> 10);
  1068. oper = per;
  1069. flush();
  1070. }
  1071. #endif
  1072. } while (tracksize < 0 || bytes_read < tracksize);
  1074. if ((bytes / secsize) < 300) {
  1075. amount = roundup(trackp->padsize, secsize);
  1076. if (((bytes+amount) / secsize) < 300)
  1077. trackp->padsize = 300 * secsize - bytes;
  1078. }
  1079. if (trackp->padsize) {
  1080. if (neednl) {
  1081. printf("n");
  1082. neednl = FALSE;
  1083. }
  1084. if ((trackp->padsize >> 20) > 0) {
  1085. neednl = TRUE;
  1086. } else if (lverbose) {
  1087. printf("Track %02d: writing %3ld KB of pad data.n",
  1088. track, trackp->padsize >> 10);
  1089. neednl = FALSE;
  1090. }
  1091. pad_track(scgp, dp, track, trackp, startsec, trackp->padsize,
  1092. TRUE, &amount);
  1093. bytes += amount;
  1094. startsec += amount / secsize;
  1095. }
  1096. printf("%sTrack %02d: Total bytes read/written: %ld/%ld (%ld sectors).n",
  1097.        neednl?"n":"", track, bytes_read, bytes, bytes/secsize);
  1098. flush();
  1099. return 0;
  1100. }
  1102. EXPORT int
  1103. pad_track(scgp, dp, track, trackp, startsec, amt, dolast, bytesp)
  1104. SCSI *scgp;
  1105. cdr_t *dp;
  1106. int track;
  1107. track_t *trackp;
  1108. long startsec;
  1109. long amt;
  1110. BOOL dolast;
  1111. long *bytesp;
  1112. {
  1113. long bytes = 0;
  1114. long savbytes = 0;
  1115. int secsize;
  1116. int secspt;
  1117. int bytespt;
  1118. int amount;
  1119. BOOL neednl = FALSE;
  1120. BOOL islast = FALSE;
  1122. secsize = trackp->secsize;
  1123. secspt = trackp->secspt;
  1124. bytespt = secsize * secspt;
  1126. fillbytes(buf, bytespt, '');
  1128. if ((amt >> 20) > 0) {
  1129. printf("rTrack %02d:   0 of %3ld MB pad written.",
  1130. track, amt >> 20);
  1131. flush();
  1132. }
  1133. do {
  1134. if (amt < bytespt) {
  1135. bytespt = roundup(amt, secsize);
  1136. secspt = bytespt / secsize;
  1137. }
  1138. if (dolast && (amt - bytespt) <= 0)
  1139. islast = TRUE;
  1141. amount = (*dp->cdr_write_trackdata)(scgp, buf, startsec, bytespt, secspt, islast);
  1142. if (amount < 0) {
  1143. printf("%swrite track data: error after %ld bytesn",
  1144. neednl?"n":"", bytes);
  1145. if (bytesp)
  1146. *bytesp = bytes;
  1147. read_buff_cap(scgp, 0, 0);
  1148. return (-1);
  1149. }
  1150. amt -= amount;
  1151. bytes += amount;
  1152. startsec += amount / secsize;
  1154. if (lverbose && (bytes >= (savbytes + 0x100000))) {
  1155. printf("rTrack %02d: %3ld", track, bytes >> 20);
  1156. savbytes = (bytes >> 20) << 20;
  1157. flush();
  1158. neednl = TRUE;
  1159. }
  1160. } while (amt > 0);
  1162. if (bytesp)
  1163. *bytesp = bytes;
  1164. return (bytes);
  1165. }
  1167. #ifdef USE_WRITE_BUF
  1168. EXPORT int
  1169. write_buf(scgp, dp, track, trackp, bp, startsec, amt, secsize, dolast, bytesp)
  1170. SCSI *scgp;
  1171. cdr_t *dp;
  1172. int track;
  1173. track_t *trackp;
  1174. char *bp;
  1175. long startsec;
  1176. long amt;
  1177. int secsize;
  1178. BOOL dolast;
  1179. long *bytesp;
  1180. {
  1181. long bytes = 0;
  1182. long savbytes = 0;
  1183. /* int secsize;*/
  1184. int secspt;
  1185. int bytespt;
  1186. int amount;
  1187. BOOL neednl = FALSE;
  1188. BOOL islast = FALSE;
  1190. /* secsize = trackp->secsize;*/
  1191. /* secspt = trackp->secspt;*/
  1193. secspt = bufsize/secsize;
  1194. secspt = min(255, secspt);
  1195. bytespt = secsize * secspt;
  1197. /* fillbytes(buf, bytespt, '');*/
  1199. if ((amt >> 20) > 0) {
  1200. printf("rTrack %02d:   0 of %3ld MB pad written.",
  1201. track, amt >> 20);
  1202. flush();
  1203. }
  1204. do {
  1205. if (amt < bytespt) {
  1206. bytespt = roundup(amt, secsize);
  1207. secspt = bytespt / secsize;
  1208. }
  1209. if (dolast && (amt - bytespt) <= 0)
  1210. islast = TRUE;
  1212. amount = (*dp->cdr_write_trackdata)(scgp, bp, startsec, bytespt, secspt, islast);
  1213. if (amount < 0) {
  1214. printf("%swrite track data: error after %ld bytesn",
  1215. neednl?"n":"", bytes);
  1216. if (bytesp)
  1217. *bytesp = bytes;
  1218. read_buff_cap(scgp, 0, 0);
  1219. return (-1);
  1220. }
  1221. amt -= amount;
  1222. bytes += amount;
  1223. startsec += amount / secsize;
  1225. if (lverbose && (bytes >= (savbytes + 0x100000))) {
  1226. printf("rTrack %02d: %3ld", track, bytes >> 20);
  1227. savbytes = (bytes >> 20) << 20;
  1228. flush();
  1229. neednl = TRUE;
  1230. }
  1231. } while (amt > 0);
  1233. if (bytesp)
  1234. *bytesp = bytes;
  1235. return (bytes);
  1236. }
  1237. #endif /* USE_WRITE_BUF */
  1239. LOCAL void
  1240. printdata(track, trackp)
  1241. int track;
  1242. track_t *trackp;
  1243. {
  1244. if (trackp->tracksize >= 0) {
  1245. printf("Track %02d: data  %3ld MB        ",
  1246. track, trackp->tracksize >> 20);
  1247. } else {
  1248. printf("Track %02d: data  unknown length",
  1249. track);
  1250. }
  1251. if (trackp->padsize > 0) {
  1252. if ((trackp->padsize >> 20) > 0)
  1253. printf(" padsize: %3ld MB", trackp->padsize >> 20);
  1254. else
  1255. printf(" padsize: %3ld KB", trackp->padsize >> 10);
  1256. }
  1257. if (trackp->pregapsize != 150) {
  1258. printf(" pregapsize: %3ld", trackp->pregapsize);
  1259. }
  1260. printf("n");
  1261. }
  1263. LOCAL void
  1264. printaudio(track, trackp)
  1265. int track;
  1266. track_t *trackp;
  1267. {
  1268. if (trackp->tracksize >= 0) {
  1269. printf("Track %02d: audio %3ld MB (%02d:%02d.%02d) %spreemp%s%s",
  1270. track, trackp->tracksize >> 20,
  1271. minutes(trackp->tracksize),
  1272. seconds(trackp->tracksize),
  1273. hseconds(trackp->tracksize),
  1274. is_preemp(trackp) ? "" : "no ",
  1275. is_swab(trackp) ? " swab":"",
  1276. ((trackp->tracksize < 300L*trackp->secsize) ||
  1277. (trackp->tracksize % trackp->secsize)) &&
  1278. is_pad(trackp) ? " pad" : "");
  1279. } else {
  1280. printf("Track %02d: audio unknown length    %spreemp%s%s",
  1281. track, is_preemp(trackp) ? "" : "no ",
  1282. is_swab(trackp) ? " swab":"",
  1283. (trackp->tracksize % trackp->secsize) && is_pad(trackp) ? " pad" : "");
  1284. }
  1285. if (trackp->padsize > 0) {
  1286. if ((trackp->padsize >> 20) > 0)
  1287. printf(" padsize: %3ld MB", trackp->padsize >> 20);
  1288. else
  1289. printf(" padsize: %3ld KB", trackp->padsize >> 10);
  1290. printf(" (%02d:%02d.%02d)",
  1291. minutes(trackp->padsize),
  1292. seconds(trackp->padsize),
  1293. hseconds(trackp->padsize));
  1294. }
  1295. if (trackp->pregapsize != 150) {
  1296. printf(" pregapsize: %3ld", trackp->pregapsize);
  1297. }
  1298. printf("n");
  1299. }
  1301. LOCAL void
  1302. checkfile(track, trackp)
  1303. int track;
  1304. track_t *trackp;
  1305. {
  1306. if (trackp->tracksize > 0 &&
  1307. is_audio(trackp) &&
  1308. ((trackp->tracksize < 300L*trackp->secsize) ||
  1309. (trackp->tracksize % trackp->secsize)) &&
  1310. !is_pad(trackp)) {
  1311. errmsgno(EX_BAD, "Bad audio track size %ld for track %02d.n",
  1312. trackp->tracksize, track);
  1313. errmsgno(EX_BAD, "Audio tracks must be at least %ld bytes and a multiple of %d.n",
  1314. 300L*trackp->secsize, trackp->secsize);
  1315. comerrno(EX_BAD, "See -pad option.n");
  1316. }
  1318. if (!lverbose)
  1319. return;
  1321. if (is_audio(trackp))
  1322. printaudio(track, trackp);
  1323. else
  1324. printdata(track, trackp);
  1325. }
  1327. LOCAL int
  1328. checkfiles(tracks, trackp)
  1329. int tracks;
  1330. track_t *trackp;
  1331. {
  1332. int i;
  1333. int isaudio = 1;
  1335. for (i = 1; i <= tracks; i++) {
  1336. if (!is_audio(&trackp[i]))
  1337. isaudio = 0;
  1338. checkfile(i, &trackp[i]);
  1339. }
  1340. return (isaudio);
  1341. }
  1343. LOCAL void
  1344. setpregaps(tracks, trackp)
  1345. int tracks;
  1346. track_t *trackp;
  1347. {
  1348. int i;
  1349. int sectype;
  1350. track_t *tp;
  1352. /*
  1353.  * Set some values for track 0 (the lead-in)
  1354.  * XXX There should be a better place to do this.
  1355.  */
  1356. sectype = trackp[1].sectype;
  1357. trackp[0].sectype = sectype;
  1358. trackp[0].dbtype = trackp[1].dbtype;
  1360. for (i = 1; i <= tracks; i++) {
  1361. tp = &trackp[i];
  1362. if (tp->pregapsize == -1L) {
  1363. tp->pregapsize = 150; /* Default Pre GAP */
  1364. if (sectype != tp->sectype) {
  1365. tp->pregapsize = 255; /* Pre GAP is 255 */
  1366. tp->flags &= ~TI_PREGAP;
  1367. }
  1368. }
  1369. sectype = tp->sectype; /* Save old sectype */
  1370. }
  1371. /*
  1372.  * Set some values for track 0xAA (the lead-out)
  1373.  * XXX There should be a better place to do this.
  1374.  */
  1375. trackp[tracks+1].sectype = sectype;
  1376. trackp[tracks+1].dbtype = trackp[tracks].dbtype;
  1377. }
  1379. LOCAL long
  1380. checktsize(tracks, trackp)
  1381. int tracks;
  1382. track_t *trackp;
  1383. {
  1384. int i;
  1385. long curr;
  1386. long total = -150;
  1387. Ullong btotal;
  1388. track_t *tp;
  1390. for (i = 1; i <= tracks; i++) {
  1391. tp = &trackp[i];
  1392. if (!is_pregap(tp))
  1393. total += tp->pregapsize;
  1395. if (lverbose > 1) {
  1396. printf("track: %d start: %ld pregap: %ldn",
  1397. i, total, tp->pregapsize);
  1398. }
  1399. tp->trackstart = total;
  1400. if (tp->tracksize >= 0) {
  1401. curr = (tp->tracksize + (tp->secsize-1)) / tp->secsize;
  1402. curr += (tp->padsize + (tp->secsize-1)) / tp->secsize;
  1404. if (curr < 300) /* Minimum track size is 4s */
  1405. curr = 300;
  1406. if (is_tao(tp) && !is_audio(tp)) {
  1407. curr += 2;
  1408. }
  1409. total += curr;
  1410. }
  1411. }
  1412. tp = &trackp[i];
  1413. tp->trackstart = total;
  1414. if (!lverbose)
  1415. return (total);
  1417. btotal = (Ullong)total * 2352;
  1418. /* XXX Sector Size ??? */
  1419. if (tracks > 0) {
  1420. printf("Total size:     %3lu MB (%02d:%02d.%02d) = %ld sectorsn",
  1421. (Ulong)(btotal >> 20),
  1422. minutes(btotal),
  1423. seconds(btotal),
  1424. hseconds(btotal), total);
  1425. btotal += 150 * 2352;
  1426. printf("Lout start:     %3lu MB (%02d:%02d/%02d) = %ld sectorsn",
  1427. (Ulong)(btotal >> 20),
  1428. minutes(btotal),
  1429. seconds(btotal),
  1430. frames(btotal), total);
  1431. }
  1432. return (total);
  1433. }
  1435. LOCAL void
  1436. checksize(trackp)
  1437. track_t *trackp;
  1438. {
  1439. struct stat st;
  1441. /*
  1442.  * If the current input file is a regular file and
  1443.  * 'padsize=' has not been specified,
  1444.  * use fstat() or file parser to get the size of the file.
  1445.  */
  1446. if (trackp->tracksize < 0 && (trackp->flags & TI_ISOSIZE) != 0) {
  1447. trackp->tracksize = isosize(trackp->f);
  1448. }
  1449. if (trackp->tracksize < 0 && (trackp->flags & TI_NOAUHDR) == 0) {
  1450. trackp->tracksize = ausize(trackp->f);
  1451. }
  1452. if (trackp->tracksize < 0 && (trackp->flags & TI_NOAUHDR) == 0) {
  1453. trackp->tracksize = wavsize(trackp->f);
  1454. if (trackp->tracksize > 0) /* Force little endian input */
  1455. trackp->flags |= TI_SWAB;
  1456. }
  1457. if (trackp->tracksize == AU_BAD_CODING) {
  1458. comerrno(EX_BAD, "Inappropriate audio coding in '%s'.n",
  1459. trackp->filename);
  1460. }
  1461. if (trackp->tracksize < 0 &&
  1462. fstat(trackp->f, &st) >= 0 && S_ISREG(st.st_mode)) {
  1463. trackp->tracksize = st.st_size;
  1464. }
  1465. }
  1467. LOCAL BOOL
  1468. checkdsize(scgp, dp, dsp, tsize)
  1469. SCSI *scgp;
  1470. cdr_t *dp;
  1471. dstat_t *dsp;
  1472. long tsize;
  1473. {
  1474. long startsec = 0L;
  1475. long endsec = 0L;
  1477. scgp->silent++;
  1478. (*dp->cdr_next_wr_address)(scgp, /*i*/ 0, (track_t *)0, &startsec);
  1479. scgp->silent--;
  1481. /*
  1482.  * This only should happen when the drive is currently in DAO mode.
  1483.  * We rely on the drive being in TAO mode, a negative value for
  1484.  * startsec is not correct here it may be caused by bad firmware or
  1485.  * by a drive in DAO mode. In DAO mode the drive will report the
  1486.  * pre-gap as part of the writable area.
  1487.  */
  1488. if (startsec < 0)
  1489. startsec = 0;
  1491. endsec = startsec + tsize;
  1493. if (dsp->ds_maxblocks > 0) {
  1494. if (lverbose)
  1495. printf("Blocks total: %ld Blocks current: %ld Blocks remaining: %ldn",
  1496. dsp->ds_maxblocks,
  1497. dsp->ds_maxblocks - startsec,
  1498. dsp->ds_maxblocks - endsec);
  1500. if (endsec > dsp->ds_maxblocks) {
  1501. errmsgno(EX_BAD,
  1502. "WARNING: Data may not fit on current disk.n");
  1504. /* XXX Check for flags & CDR_NO_LOLIMIT */
  1505. /* return (FALSE);*/
  1506. }
  1507. if (lverbose && dsp->ds_maxrblocks > 0)
  1508. printf("RBlocks total: %ld RBlocks current: %ld RBlocks remaining: %ldn",
  1509. dsp->ds_maxrblocks,
  1510. dsp->ds_maxrblocks - startsec,
  1511. dsp->ds_maxrblocks - endsec);
  1512. if (dsp->ds_maxrblocks > 0 && endsec > dsp->ds_maxrblocks) {
  1513. errmsgno(EX_BAD,
  1514. "Data does not fit on current disk.n");
  1515. return (FALSE);
  1516. }
  1517. } else {
  1518. if (endsec >= (405000-301)) { /*<90 min disk*/
  1519. errmsgno(EX_BAD,
  1520. "Data will not fit on any disk.n");
  1521. return (FALSE);
  1522. } else if (endsec >= (333000-150)) { /* 74 min disk*/
  1523. errmsgno(EX_BAD,
  1524. "WARNING: Data may not fit on standard 74min disk.n");
  1525. }
  1526. }
  1527. return (TRUE);
  1528. }
  1530. LOCAL void
  1531. raise_fdlim()
  1532. {
  1533. #ifdef RLIMIT_NOFILE
  1535. struct rlimit rlim;
  1537. /*
  1538.  * Set max # of file descriptors to be able to hold all files open
  1539.  */
  1540. getrlimit(RLIMIT_NOFILE, &rlim);
  1541. rlim.rlim_cur = MAX_TRACK + 10;
  1542. if (rlim.rlim_cur > rlim.rlim_max)
  1543. errmsgno(EX_BAD,
  1544. "warning: low file descriptor limit (%ld)n",
  1545. rlim.rlim_max);
  1546. setrlimit(RLIMIT_NOFILE, &rlim);
  1548. #endif /* RLIMIT_NOFILE */
  1549. }
  1551. char *opts =
  1552. "help,version,checkdrive,prcap,inq,scanbus,reset,ignsize,useinfo,dev*,timeout#,driver*,tsize&,padsize&,pregap&,defpregap&,speed#,load,eject,dummy,msinfo,toc,atip,multi,fix,nofix,debug,v+,V+,audio,data,mode2,xa1,xa2,cdi,isosize,nopreemp,preemp,nopad,pad,swab,fs&,blank&,pktsize#,packet,noclose,force,dao,scms,isrc*,mcn*,index*";
  1554. LOCAL void
  1555. gargs(ac, av, tracksp, trackp, devp, timeoutp, dpp, speedp, flagsp, toctypep, blankp)
  1556. int ac;
  1557. char **av;
  1558. int *tracksp;
  1559. track_t *trackp;
  1560. cdr_t **dpp;
  1561. char **devp;
  1562. int *timeoutp;
  1563. int *speedp;
  1564. long *flagsp;
  1565. int *toctypep;
  1566. int *blankp;
  1567. {
  1568. int cac;
  1569. char * const*cav;
  1570. char *driver = NULL;
  1571. char *dev = NULL;
  1572. char *isrc = NULL;
  1573. char *mcn = NULL;
  1574. char *tindex = NULL;
  1575. long bltype = -1;
  1576. Llong tracksize;
  1577. Llong padsize;
  1578. long pregapsize;
  1579. long defpregap = -1L;
  1580. long secsize;
  1581. int pktsize;
  1582. int speed = -1;
  1583. int help = 0;
  1584. int version = 0;
  1585. int checkdrive = 0;
  1586. int prcap = 0;
  1587. int inq = 0;
  1588. int scanbus = 0;
  1589. int reset = 0;
  1590. int ignsize = 0;
  1591. int useinfo = 0;
  1592. int load = 0;
  1593. int eject = 0;
  1594. int dummy = 0;
  1595. int msinfo = 0;
  1596. int toc = 0;
  1597. int atip = 0;
  1598. int multi = 0;
  1599. int fix = 0;
  1600. int nofix = 0;
  1601. int audio;
  1602. int autoaudio = 0;
  1603. int data;
  1604. int mode2;
  1605. int xa1;
  1606. int xa2;
  1607. int cdi;
  1608. int isize;
  1609. int ispacket = 0;
  1610. int noclose = 0;
  1611. int force = 0;
  1612. int dao = 0;
  1613. int scms = 0;
  1614. int preemp = 0;
  1615. int nopreemp;
  1616. int pad = 0;
  1617. int bswab = 0;
  1618. int nopad;
  1619. int flags;
  1620. int tracks = *tracksp;
  1621. int tracktype = TOC_ROM;
  1622. int sectype = ST_ROM_MODE1;
  1623. int dbtype = DB_ROM_MODE1;
  1624. int got_track;
  1626. trackp[0].flags |= TI_TAO;
  1627. trackp[1].pregapsize = -1;
  1628. *flagsp |= F_WRITE;
  1630. cac = --ac;
  1631. cav = ++av;
  1632. for (;; cac--, cav++) {
  1633. tracksize = (Llong)-1L;
  1634. padsize = (Llong)0L;
  1635. pregapsize = defpregap;
  1636. audio = data = mode2 = xa1 = xa2 = cdi = 0;
  1637. isize = nopreemp = nopad = 0;
  1638. pktsize = 0;
  1639. isrc = NULL;
  1640. tindex = NULL;
  1641. if (getargs(&cac, &cav, opts,
  1642. &help, &version, &checkdrive, &prcap,
  1643. &inq, &scanbus, &reset, &ignsize,
  1644. &useinfo,
  1645. devp, timeoutp, &driver,
  1646. getllnum, &tracksize,
  1647. getllnum, &padsize,
  1648. getnum, &pregapsize,
  1649. getnum, &defpregap,
  1650. &speed,
  1651. &load, &eject, &dummy, &msinfo, &toc, &atip,
  1652. &multi, &fix, &nofix,
  1653. &debug, &lverbose, &scsi_verbose,
  1654. &audio, &data, &mode2,
  1655. &xa1, &xa2, &cdi,
  1656. &isize,
  1657. &nopreemp, &preemp,
  1658. &nopad, &pad, &bswab, getnum, &fs,
  1659. getbltype, &bltype, &pktsize,
  1660. &ispacket, &noclose, &force,
  1661. &dao, &scms,
  1662. &isrc, &mcn, &tindex) < 0) {
  1663. errmsgno(EX_BAD, "Bad Option: %s.n", cav[0]);
  1664. usage(EX_BAD);
  1665. }
  1666. if (help)
  1667. usage(0);
  1668. if (tracks == 0) {
  1669. if (driver)
  1670. set_cdrcmds(driver, dpp);
  1671. if (version)
  1672. *flagsp |= F_VERSION;
  1673. if (checkdrive)
  1674. *flagsp |= F_CHECKDRIVE;
  1675. if (prcap)
  1676. *flagsp |= F_PRCAP;
  1677. if (inq)
  1678. *flagsp |= F_INQUIRY;
  1679. if (scanbus)
  1680. *flagsp |= F_SCANBUS;
  1681. if (reset)
  1682. *flagsp |= F_RESET;
  1683. if (ignsize)
  1684. *flagsp |= F_IGNSIZE;
  1685. if (load)
  1686. *flagsp |= F_LOAD;
  1687. if (eject)
  1688. *flagsp |= F_EJECT;
  1689. if (dummy)
  1690. *flagsp |= F_DUMMY;
  1691. if (msinfo)
  1692. *flagsp |= F_MSINFO;
  1693. if (toc) {
  1694. *flagsp |= F_TOC;
  1695. *flagsp &= ~F_WRITE;
  1696. }
  1697. if (atip) {
  1698. *flagsp |= F_PRATIP;
  1699. *flagsp &= ~F_WRITE;
  1700. }
  1701. if (multi) {
  1702. *flagsp |= F_MULTI;
  1703. tracktype = TOC_XA2;
  1704. sectype = ST_ROM_MODE2;
  1705. dbtype = DB_XA_MODE2; /* XXX -multi nimmt DB_XA_MODE2_F1 !!! */
  1706. }
  1707. if (fix)
  1708. *flagsp |= F_FIX;
  1709. if (nofix)
  1710. *flagsp |= F_NOFIX;
  1711. if (force) 
  1712. *flagsp |= F_FORCE;
  1714. if (bltype >= 0) {
  1715. *flagsp |= F_BLANK;
  1716. *blankp = bltype;
  1717. }
  1718. if (dao) {
  1719. *flagsp |= F_SAO;
  1720. trackp[0].flags &= ~TI_TAO;
  1721. }
  1722. if (mcn) {
  1723. #ifdef AUINFO
  1724. setmcn(mcn, &trackp[0]);
  1725. #else
  1726. trackp[0].isrc = malloc(16);
  1727. fillbytes(trackp[0].isrc, 16, '');
  1728. strncpy(trackp[0].isrc, mcn, 13);
  1729. #endif
  1730. mcn = NULL;
  1731. }
  1732. version = checkdrive = prcap = inq = scanbus = reset = ignsize =
  1733. load = eject = dummy = msinfo = toc = atip = multi = fix = nofix = force = dao = 0;
  1734. } else if ((version + checkdrive + prcap + inq + scanbus + reset + ignsize +
  1735.     load + eject + dummy + msinfo + toc + atip + multi + fix + nofix + force + dao) > 0 ||
  1736. mcn != NULL)
  1737. comerrno(EX_BAD, "Badly placed option. Global options must be before any track.n");
  1739. if (nopreemp)
  1740. preemp = 0;
  1741. if (nopad)
  1742. pad = 0;
  1744. if ((audio + data + mode2 + xa1 + xa2 + cdi) > 1) {
  1745. errmsgno(EX_BAD, "Too many types for track %d.n", tracks+1);
  1746. comerrno(EX_BAD, "Only one of -audio, -data, -mode2, -xa1, -xa2, -cdi allowed.n");
  1747. }
  1748. if (ispacket && audio) {
  1749. comerrno(EX_BAD, "Audio data cannot be written in packet mode.n");
  1750. }
  1751. got_track = getfiles(&cac, &cav, opts);
  1752. if (autoaudio) {
  1753. autoaudio = 0;
  1754. tracktype = TOC_ROM;
  1755. sectype = ST_ROM_MODE1;
  1756. dbtype = DB_ROM_MODE1;
  1757. }
  1758. if (got_track != 0 && (is_auname(cav[0]) || is_wavname(cav[0]))) {
  1759. autoaudio++;
  1760. audio++;
  1761. }
  1762. if (data) {
  1763. tracktype = TOC_ROM;
  1764. sectype = ST_ROM_MODE1;
  1765. dbtype = DB_ROM_MODE1;
  1766. }
  1767. if (mode2) {
  1768. tracktype = TOC_ROM;
  1769. sectype = ST_ROM_MODE2;
  1770. dbtype = DB_ROM_MODE2;
  1771. }
  1772. if (audio) {
  1773. tracktype = TOC_DA;
  1774. sectype = preemp ? ST_AUDIO_PRE : ST_AUDIO_NOPRE;
  1775. dbtype = DB_RAW;
  1776. }
  1777. if (xa1) {
  1778. tracktype = TOC_XA1;
  1779. sectype = ST_ROM_MODE1;
  1780. dbtype = DB_XA_MODE1;
  1781. }
  1782. if (xa2) {
  1783. tracktype = TOC_XA2;
  1784. sectype = ST_ROM_MODE2;
  1785. dbtype = DB_XA_MODE2_F1; /* XXX Das unterscheidet sich von -multi !!! */
  1786. }
  1787. if (cdi) {
  1788. tracktype = TOC_CDI;
  1789. sectype = ST_ROM_MODE2;
  1790. dbtype = DB_XA_MODE2_F1;
  1791. }
  1792. if (tracks == 0)
  1793. *toctypep = tracktype;
  1795. flags = 0;
  1796. if ((sectype & ST_AUDIOMASK) != 0)
  1797. flags |= TI_AUDIO;
  1798. if (isize) {
  1799. flags |= TI_ISOSIZE;
  1800. if ((*flagsp & F_MULTI) != 0)
  1801. comerrno(EX_BAD, "Cannot get isosize for multi session disks.n");
  1802. }
  1803. if (preemp)
  1804. flags |= TI_PREEMP;
  1805. if (scms)
  1806. flags |= TI_SCMS;
  1808. if ((flags & TI_AUDIO) == 0 && padsize > (Llong)0L)
  1809. pad = TRUE;
  1810. if (pad) {
  1811. flags |= TI_PAD;
  1812. if ((flags & TI_AUDIO) == 0 && padsize == (Llong)0L)
  1813. padsize = (Llong)PAD_SIZE;
  1814. }
  1815. if (bswab)
  1816. flags |= TI_SWAB;
  1817. if (ispacket) 
  1818. flags |= TI_PACKET;
  1819. if (noclose) 
  1820. flags |= TI_NOCLOSE;
  1822. if ((*flagsp & F_SAO) == 0)
  1823. flags |= TI_TAO;
  1825. if (got_track == 0)
  1826. break;
  1827. tracks++;
  1829. if (tracks > MAX_TRACK)
  1830. comerrno(EX_BAD, "Track limit (%d) exceededn",
  1831. MAX_TRACK);
  1833. if (strcmp("-", cav[0]) == 0) {
  1834. trackp[tracks].f = STDIN_FILENO;
  1836. #if defined(__CYGWIN32__) || defined(__EMX__)
  1837. setmode(STDIN_FILENO, O_BINARY);
  1838. #endif
  1839. } else {
  1840. if (access(cav[0], R_OK) < 0)
  1841. comerr("No read access for '%s'.n", cav[0]);
  1843. if ((trackp[tracks].f = open(cav[0], O_RDONLY|O_BINARY)) < 0)
  1844. comerr("Cannot open '%s'.n", cav[0]);
  1845. }
  1846. if (!is_auname(cav[0]) && !is_wavname(cav[0]))
  1847. flags |= TI_NOAUHDR;
  1849. if ((*flagsp & F_SAO) != 0 && (flags & TI_AUDIO) != 0)
  1850. flags |= TI_PREGAP; /* Hack for now */
  1851. if (tracks == 1)
  1852. flags &= ~TI_PREGAP;
  1854. if (tracks == 1 && (pregapsize != -1L && pregapsize != 150))
  1855. pregapsize = -1L;
  1856. secsize = tracktype == TOC_DA ? AUDIO_SEC_SIZE : DATA_SEC_SIZE;
  1857. trackp[tracks].filename = cav[0];;
  1858. trackp[tracks].trackstart = 0L;
  1859. trackp[tracks].tracksize = tracksize;
  1860. if (trackp[tracks].pregapsize < 0)
  1861. trackp[tracks].pregapsize = pregapsize;
  1862. trackp[tracks+1].pregapsize = -1;
  1863. trackp[tracks].padsize = padsize;
  1864. trackp[tracks].secsize = secsize;
  1865. trackp[tracks].secspt = 0; /* transfer size is set up in set_trsizes() */
  1866. trackp[tracks].pktsize = pktsize;
  1867. trackp[tracks].trackno = tracks;
  1868. trackp[tracks].sectype = sectype;
  1869. trackp[tracks].tracktype = tracktype;
  1870. trackp[tracks].dbtype = dbtype;
  1871. trackp[tracks].flags = flags;
  1872. trackp[tracks].nindex = 1;
  1873. trackp[tracks].tindex = 0;
  1874. checksize(&trackp[tracks]);
  1875. tracksize = trackp[tracks].tracksize;
  1876. if (tracksize > 0 && (tracksize / secsize) < 300) {
  1877. tracksize = roundup(tracksize, secsize);
  1878. padsize = tracksize + roundup(padsize, secsize);
  1879. if ((padsize / secsize) < 300) {
  1880. trackp[tracks].padsize =
  1881. 300 * secsize - tracksize;
  1882. }
  1883. }
  1884. #ifdef AUINFO
  1885. if (useinfo) {
  1886. auinfo(cav[0], tracks, trackp);
  1887. if (tracks == 1)
  1888. printf("pregap1: %ldn", trackp[1].pregapsize);
  1889. }
  1890. #endif
  1891. if (isrc) {
  1892. #ifdef AUINFO
  1893. setisrc(isrc, &trackp[tracks]);
  1894. #else
  1895. trackp[tracks].isrc = malloc(16);
  1896. fillbytes(trackp[tracks].isrc, 16, '');
  1897. strncpy(trackp[tracks].isrc, isrc, 12);
  1898. #endif
  1899. }
  1900. if (tindex) {
  1901. #ifdef AUINFO
  1902. setindex(tindex, &trackp[tracks]);
  1903. #endif
  1904. }
  1906. if (debug) {
  1907. printf("File: '%s' tracksize: %ld secsize: %d tracktype: %d = %s sectype: %X = %s dbtype: %s flags %Xn",
  1908. cav[0], trackp[tracks].tracksize, 
  1909. trackp[tracks].secsize, 
  1910. tracktype, toc2name[tracktype & TOC_MASK],
  1911. sectype, st2name[sectype & ST_MASK], db2name[dbtype], flags);
  1912. }
  1913. }
  1915. if (speed < 0 && speed != -1)
  1916. comerrno(EX_BAD, "Bad speed option.n");
  1918. if (fs < 0L && fs != -1L)
  1919. comerrno(EX_BAD, "Bad fifo size option.n");
  1921. dev = *devp;
  1922. cdr_defaults(&dev, &speed, &fs);
  1923. if (debug)
  1924. printf("dev: %s speed: %d fs: %ldn", dev, speed, fs);
  1926. if (speed >= 0)
  1927. *speedp = speed;
  1929. if (fs < 0L)
  1930. fs = DEFAULT_FIFOSIZE;
  1932. if (dev != *devp && (*flagsp & F_SCANBUS) == 0)
  1933. *devp = dev;
  1935. if (!*devp && (*flagsp & (F_VERSION|F_SCANBUS)) == 0) {
  1936. errmsgno(EX_BAD, "No CD/DVD-Recorder device specified.n");
  1937. usage(EX_BAD);
  1938. }
  1939. if (*flagsp & (F_LOAD|F_MSINFO|F_TOC|F_PRATIP|F_FIX|F_VERSION|F_CHECKDRIVE|F_PRCAP|F_INQUIRY|F_SCANBUS|F_RESET)) {
  1940. if (tracks != 0) {
  1941. errmsgno(EX_BAD, "No tracks allowed with this optionn");
  1942. usage(EX_BAD);
  1943. }
  1944. return;
  1945. }
  1946. if (tracks == 0 && (*flagsp & (F_LOAD|F_EJECT|F_BLANK)) == 0) {
  1947. errmsgno(EX_BAD, "No tracks specified. Need at least one.n");
  1948. usage(EX_BAD);
  1949. }
  1950. *tracksp = tracks;
  1951. if (*flagsp & F_SAO) {
  1952. /*
  1953.  * Make sure that you change WRITER_MAXWAIT & READER_MAXWAIT
  1954.  * too if you change this timeout.
  1955.  */
  1956. if (*timeoutp < 200) /* Lead in size is 2:30 */
  1957. *timeoutp = 200; /* 200s is 150s *1.33 */
  1958. }
  1959. }
  1961. LOCAL void
  1962. set_trsizes(dp, tracks, trackp)
  1963. cdr_t *dp;
  1964. int tracks;
  1965. track_t *trackp;
  1966. {
  1967. int i;
  1969. /*
  1970.  * We are using SCSI Group 0 write
  1971.  * and cannot write more than 255 secs at once.
  1972.  */
  1973. data_secs_per_tr = bufsize/DATA_SEC_SIZE;
  1974. audio_secs_per_tr = bufsize/AUDIO_SEC_SIZE;
  1975. data_secs_per_tr = min(255, data_secs_per_tr);
  1976. audio_secs_per_tr = min(255, audio_secs_per_tr);
  1978. trackp[1].flags |= TI_FIRST;
  1979. trackp[tracks].flags |= TI_LAST;
  1981. for (i = 1; i <= tracks; i++) {
  1982. trackp[i].secspt =
  1983. is_audio(&trackp[i]) ?
  1984. audio_secs_per_tr :
  1985. data_secs_per_tr;
  1986. if (is_packet(&trackp[i]) && trackp[i].pktsize > 0) {
  1987. if (trackp[i].secspt >= trackp[i].pktsize) {
  1988. trackp[i].secspt = trackp[i].pktsize;
  1989. } else {
  1990. comerrno(EX_BAD,
  1991. "Track %d packet size %d exceeds buffer limit of %d sectors",
  1992. i, trackp[i].pktsize, trackp[i].secspt);
  1993. }
  1994. }
  1995. if ((dp->cdr_flags & CDR_SWABAUDIO) != 0 &&
  1996. is_audio(&trackp[i])) {
  1997. trackp[i].flags ^= TI_SWAB;
  1998. }
  1999. }
  2000. }
  2002. EXPORT void
  2003. load_media(scgp, dp, doexit)
  2004. SCSI *scgp;
  2005. cdr_t *dp;
  2006. BOOL doexit;
  2007. {
  2008. int code;
  2009. int key;
  2011. /*
  2012.  * Do some preparation before...
  2013.  */
  2014. scgp->silent++; /* Be quiet if this fails */
  2015. test_unit_ready(scgp); /* First eat up unit attention */
  2016. (*dp->cdr_load)(scgp); /* now try to load media and */
  2017. scsi_start_stop_unit(scgp, 1, 0);/* start unit in silent mode */
  2018. scgp->silent--;
  2020. if (!wait_unit_ready(scgp, 60)) {
  2021. code = scsi_sense_code(scgp);
  2022. key = scsi_sense_key(scgp);
  2023. scgp->silent++;
  2024. scsi_prevent_removal(scgp, 0);/* In case someone locked it */
  2025. scgp->silent--;
  2027. if (!doexit)
  2028. return;
  2029. if (key == SC_NOT_READY && (code == 0x3A || code == 0x30))
  2030. comerrno(EX_BAD, "No disk / Wrong disk!n");
  2031. comerrno(EX_BAD, "CD/DVD-Recorder not ready.n");
  2032. }
  2034. scsi_prevent_removal(scgp, 1);
  2035. scsi_start_stop_unit(scgp, 1, 0);
  2036. wait_unit_ready(scgp, 120);
  2037. scgp->silent++;
  2038. rezero_unit(scgp); /* Is this needed? Not supported by some drvives */
  2039. scgp->silent--;
  2040. test_unit_ready(scgp);
  2041. scsi_start_stop_unit(scgp, 1, 0);
  2042. wait_unit_ready(scgp, 120);
  2043. }
  2045. EXPORT void
  2046. unload_media(scgp, dp, flags)
  2047. SCSI *scgp;
  2048. cdr_t *dp;
  2049. int flags;
  2050. {
  2051. scsi_prevent_removal(scgp, 0);
  2052. if ((flags & F_EJECT) != 0)
  2053. (*dp->cdr_unload)(scgp);
  2054. }
  2056. EXPORT void
  2057. set_secsize(scgp, secsize)
  2058. SCSI *scgp;
  2059. int secsize;
  2060. {
  2061. if (secsize > 0) {
  2062. /*
  2063.  * Try to restore the old sector size.
  2064.  */
  2065. scgp->silent++;
  2066. select_secsize(scgp, secsize);
  2067. scgp->silent--;
  2068. }
  2069. }
  2071. LOCAL void
  2072. check_recovery(scgp, dp, flags)
  2073. SCSI *scgp;
  2074. cdr_t *dp;
  2075. int flags;
  2076. {
  2077. if ((*dp->cdr_check_recovery)(scgp)) {
  2078. errmsgno(EX_BAD, "Recovery needed.n");
  2079. unload_media(scgp, dp, flags);
  2080. excdr(EX_BAD, NULL); /* XXX &exargs ??? */
  2081. exit(EX_BAD);
  2082. }
  2083. }
  2085. #define DEBUG
  2086. void audioread(scgp, dp, flags)
  2087. SCSI *scgp;
  2088. cdr_t *dp;
  2089. int flags;
  2090. {
  2091. #ifdef DEBUG
  2092. int speed = 1;
  2093. int dummy = 0;
  2095. if ((*dp->cdr_set_speed_dummy)(scgp, &speed, dummy) < 0)
  2096. exit(-1);
  2097. if ((*dp->cdr_set_secsize)(scgp, 2352) < 0)
  2098. exit(-1);
  2099. scgp->cap->c_bsize = 2352;
  2101. read_scsi(scgp, buf, 1000, 1);
  2102. printf("XXX:n");
  2103. write(1, buf, 512);
  2104. unload_media(scgp, dp, flags);
  2105. excdr(0, NULL); /* XXX &exargs ??? */
  2106. exit(0);
  2107. #endif
  2108. }
  2110. LOCAL void
  2111. print_msinfo(scgp, dp)
  2112. SCSI *scgp;
  2113. cdr_t *dp;
  2114. {
  2115. long off;
  2116. long fa;
  2118. if ((*dp->cdr_session_offset)(scgp, &off) < 0) {
  2119. errmsgno(EX_BAD, "Cannot read session offsetn");
  2120. return;
  2121. }
  2122. if (lverbose)
  2123. printf("session offset: %ldn", off);
  2125. if (dp->cdr_next_wr_address(scgp, 0, (track_t *)0, &fa) < 0) {
  2126. errmsgno(EX_BAD, "Cannot read first writable addressn");
  2127. return;
  2128. }
  2129. printf("%ld,%ldn", off, fa);
  2130. }
  2132. LOCAL void
  2133. print_toc(scgp, dp)
  2134. SCSI *scgp;
  2135. cdr_t *dp;
  2136. {
  2137. int first;
  2138. int last;
  2139. long lba;
  2140. long xlba;
  2141. struct msf msf;
  2142. int adr;
  2143. int control;
  2144. int mode;
  2145. int i;
  2147. scgp->silent++;
  2148. if (read_capacity(scgp) < 0) {
  2149. scgp->silent--;
  2150. errmsgno(EX_BAD, "Cannot read capacityn");
  2151. return;
  2152. }
  2153. scgp->silent--;
  2154. if (read_tochdr(scgp, dp, &first, &last) < 0) {
  2155. errmsgno(EX_BAD, "Cannot read TOC/PMAn");
  2156. return;
  2157. }
  2158. printf("first: %d last %dn", first, last);
  2159. for (i = first; i <= last; i++) {
  2160. read_trackinfo(scgp, i, &lba, &msf, &adr, &control, &mode);
  2161. xlba = -150 +
  2162. msf.msf_frame + (75*msf.msf_sec) + (75*60*msf.msf_min);
  2163. if (xlba == lba/4)
  2164. lba = xlba;
  2165. print_track(i, lba, &msf, adr, control, mode);
  2166. }
  2167. i = 0xAA;
  2168. read_trackinfo(scgp, i, &lba, &msf, &adr, &control, &mode);
  2169. xlba = -150 +
  2170. msf.msf_frame + (75*msf.msf_sec) + (75*60*msf.msf_min);
  2171. if (xlba == lba/4)
  2172. lba = xlba;
  2173. print_track(i, lba, &msf, adr, control, mode);
  2174. if (lverbose > 1) {
  2175. scgp->silent++;
  2176. if (read_cdtext(scgp) < 0)
  2177. errmsgno(EX_BAD, "No CD-Text or CD-Text unaware drive.n");
  2178. scgp->silent++;
  2179. }
  2180. }
  2182. LOCAL void
  2183. print_track(track, lba, msp, adr, control, mode)
  2184. int track;
  2185. long lba;
  2186. struct msf *msp;
  2187. int adr;
  2188. int control;
  2189. int mode;
  2190. {
  2191. long lba_512 = lba*4;
  2193. if (track == 0xAA)
  2194. printf("track:lout ");
  2195. else
  2196. printf("track: %3d ", track);
  2198. printf("lba: %9ld (%9ld) %02d:%02d:%02d adr: %X control: %X mode: %dn",
  2199. lba, lba_512,
  2200. msp->msf_min,
  2201. msp->msf_sec,
  2202. msp->msf_frame,
  2203. adr, control, mode);
  2204. }
  2206. LOCAL void
  2207. prtimediff(fmt, start, stop)
  2208. const char *fmt;
  2209. struct timeval *start;
  2210. struct timeval *stop;
  2211. {
  2212. struct timeval tv;
  2214. tv.tv_sec = stop->tv_sec - start->tv_sec;
  2215. tv.tv_usec = stop->tv_usec - start->tv_usec;
  2216. while (tv.tv_usec > 1000000) {
  2217. tv.tv_usec -= 1000000;
  2218. tv.tv_sec += 1;
  2219. }
  2220. while (tv.tv_usec < 0) {
  2221. tv.tv_usec += 1000000;
  2222. tv.tv_sec -= 1;
  2223. }
  2224. /*
  2225.  * We need to cast timeval->* to long because
  2226.  * of the broken sys/time.h in Linux.
  2227.  */
  2228. printf("%s%4ld.%03ldsn", fmt, (long)tv.tv_sec, (long)tv.tv_usec/1000);
  2229. flush();
  2230. }
  2232. #ifdef HAVE_SYS_PRIOCNTL_H
  2234. #include <sys/procset.h> /* Needed for SCO Openserver */
  2235. #include <sys/priocntl.h>
  2236. #include <sys/rtpriocntl.h>
  2238. EXPORT void
  2239. raisepri(pri)
  2240. int pri;
  2241. {
  2242. int pid;
  2243. int classes;
  2244. int ret;
  2245. pcinfo_t info;
  2246. pcparms_t param;
  2247. rtinfo_t rtinfo;
  2248. rtparms_t rtparam;
  2250. pid = getpid();
  2252. /* get info */
  2253. strcpy(info.pc_clname, "RT");
  2254. classes = priocntl(P_PID, pid, PC_GETCID, (void *)&info);
  2255. if (classes == -1)
  2256. comerr("Cannot get priority class id priocntl(PC_GETCID)n");
  2258. movebytes(info.pc_clinfo, &rtinfo, sizeof(rtinfo_t));
  2259.  
  2260. /* set priority to max */
  2261. rtparam.rt_pri = rtinfo.rt_maxpri - pri;
  2262. rtparam.rt_tqsecs = 0;
  2263. rtparam.rt_tqnsecs = RT_TQDEF;
  2264. param.pc_cid = info.pc_cid;
  2265. movebytes(&rtparam, param.pc_clparms, sizeof(rtparms_t));
  2266. ret = priocntl(P_PID, pid, PC_SETPARMS, (void *)&param);
  2267. if (ret == -1) {
  2268. errmsg("WARNING: Cannot set priority class parameters priocntl(PC_SETPARMS)n");
  2269. errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.n");
  2270. }
  2271. }
  2273. #else /* HAVE_SYS_PRIOCNTL_H */
  2275. #if defined(_POSIX_PRIORITY_SCHEDULING)
  2276. /*
  2277.  * XXX Ugly but needed because of a typo in /usr/iclude/sched.h on Linux.
  2278.  * XXX This should be removed as soon as we are sure that Linux-2.0.29 is gone.
  2279.  */
  2280. #ifdef __linux
  2281. #define _P __P
  2282. #endif
  2284. #include <sched.h>
  2286. #ifdef __linux
  2287. #undef _P
  2288. #endif
  2290. LOCAL int
  2291. rt_raisepri(pri)
  2292. int pri;
  2293. {
  2294. struct sched_param scp;
  2296. /*
  2297.  * Verify that scheduling is available
  2298.  */
  2299. #ifdef _SC_PRIORITY_SCHEDULING
  2300. if (sysconf(_SC_PRIORITY_SCHEDULING) == -1) {
  2301. errmsg("WARNING: RR-scheduler not available, disabling.n");
  2302. return(-1);
  2303. }
  2304. #endif
  2305. fillbytes(&scp, sizeof(scp), '');
  2306. scp.sched_priority = sched_get_priority_max(SCHED_RR) - pri;
  2307. if (sched_setscheduler(0, SCHED_RR, &scp) < 0) {
  2308. errmsg("WARNING: Cannot set RR-schedulern");
  2309. return (-1);
  2310. }
  2311. return (0);
  2312. }
  2314. #else /* _POSIX_PRIORITY_SCHEDULING */
  2316. #ifdef __CYGWIN32__
  2318. /*
  2319.  * NOTE: Base.h has a second typedef for BOOL.
  2320.  *  We define BOOL to make all local code use BOOL
  2321.  *  from Windows.h and use the hidden __SBOOL for
  2322.  *  our global interfaces.
  2323.  */
  2324. #define BOOL WBOOL /* This is the Win BOOL */
  2325. #define format __format
  2326. #include <vadefs.h>
  2327. #include <Windows32/Base.h>
  2328. #include <Windows32/Defines.h>
  2329. #include <Windows32/Structures.h>
  2330. #include <Windows32/Functions.h>
  2331. #undef format
  2333. LOCAL int
  2334. rt_raisepri(pri)
  2335. int pri;
  2336. {
  2337. /* set priority class */
  2338. if (SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS) == FALSE) {
  2339. errmsgno(EX_BAD, "No realtime priority class possible.n");
  2340. return (-1);
  2341. }
  2343. /* set thread priority */
  2344. if (SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL-pri) == FALSE) {
  2345. errmsgno(EX_BAD, "Could not set realtime priority.n");
  2346. return (-1);
  2347. }
  2348. return (0);
  2349. }
  2351. #else
  2353. LOCAL int
  2354. rt_raisepri(pri)
  2355. int pri;
  2356. {
  2357. return (-1);
  2358. }
  2360. #endif /* __CYGWIN32__ */
  2362. #endif /* _POSIX_PRIORITY_SCHEDULING */
  2364. EXPORT void
  2365. raisepri(pri)
  2366. int pri;
  2367. {
  2368. if (rt_raisepri(pri) >= 0)
  2369. return;
  2370. #if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
  2372. if (setpriority(PRIO_PROCESS, getpid(), -20 + pri) < 0) {
  2373. errmsg("WARNING: Cannot set priority using setpriority().n");
  2374. errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.n");
  2375. }
  2376. #else
  2377. #ifdef HAVE_DOSSETPRIORITY /* RT priority on OS/2 */
  2378. /*
  2379.  * Set priority to timecritical 31 - pri (arg)
  2380.  */
  2381. DosSetPriority(0, 3, 31, 0);
  2382. DosSetPriority(0, 3, -pri, 0);
  2383. #else
  2384. #ifdef HAVE_NICE
  2385. if (nice(-20 + pri) == -1) {
  2386. errmsg("WARNING: Cannot set priority using nice().n");
  2387. errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.n");
  2388. }
  2389. #else
  2390. errmsgno(EX_BAD, "WARNING: Cannot set priority on this OS.n");
  2391. errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.n");
  2392. #endif
  2393. #endif
  2394. #endif
  2395. }
  2397. #endif /* HAVE_SYS_PRIOCNTL_H */
  2399. LOCAL void
  2400. checkgui()
  2401. {
  2402. struct stat st;
  2404. if (fstat(STDERR_FILENO, &st) >= 0 && !S_ISCHR(st.st_mode)) {
  2405. isgui = TRUE;
  2406. if (lverbose > 1)
  2407. printf("Using remote (pipe) mode for interactive i/o.n");
  2408. }
  2409. }
  2411. LOCAL char *
  2412. astoll(s, ll)
  2413. register const char *s;
  2414.         Llong *ll;
  2415. {
  2416. char *p;
  2417. long l = 0;
  2419. p = astol(s, &l);
  2420. *ll = (Llong)l;
  2421. return (p);
  2422. }
  2424. LOCAL Llong
  2425. number(arg, retp)
  2426. register char *arg;
  2427. int *retp;
  2428. {
  2429. Llong val = 0;
  2431. if (*retp != 1)
  2432. return (val);
  2433. if (*arg == '') {
  2434. *retp = -1;
  2435. } else if (*(arg = astoll(arg, &val))) {
  2436. if (*arg == 'p' || *arg == 'P') {
  2437. val *= (1024*1024);
  2438. val *= (1024*1024*1024);
  2439. arg++;
  2440. }
  2441. if (*arg == 't' || *arg == 'T') {
  2442. val *= (1024*1024);
  2443. val *= (1024*1024);
  2444. arg++;
  2445. }
  2446. if (*arg == 'g' || *arg == 'G') {
  2447. val *= (1024*1024*1024);
  2448. arg++;
  2449. }
  2450. if (*arg == 'm' || *arg == 'M') {
  2451. val *= (1024*1024);
  2452. arg++;
  2453. }
  2454. else if (*arg == 'f' || *arg == 'F') {
  2455. val *= 2352;
  2456. arg++;
  2457. }
  2458. else if (*arg == 's' || *arg == 'S') {
  2459. val *= 2048;
  2460. arg++;
  2461. }
  2462. else if (*arg == 'k' || *arg == 'K') {
  2463. val *= 1024;
  2464. arg++;
  2465. }
  2466. else if (*arg == 'b' || *arg == 'B') {
  2467. val *= 512;
  2468. arg++;
  2469. }
  2470. else if (*arg == 'w' || *arg == 'W') {
  2471. val *= 2;
  2472. arg++;
  2473. }
  2474. if (*arg == '*' || *arg == 'x')
  2475. val *= number(++arg, retp);
  2476. else if (*arg != '')
  2477. *retp = -1;
  2478. }
  2479. return (val);
  2480. }
  2482. EXPORT int
  2483. getnum(arg, valp)
  2484. char *arg;
  2485. long *valp;
  2486. {
  2487. int ret = 1;
  2489. *valp = (long)number(arg, &ret);
  2490. return (ret);
  2491. }
  2493. EXPORT int
  2494. getllnum(arg, lvalp)
  2495. char *arg;
  2496. Llong *lvalp;
  2497. {
  2498. int ret = 1;
  2500. *lvalp = number(arg, &ret);
  2501. return (ret);
  2502. }
  2504. LOCAL int
  2505. getbltype(optstr, typep)
  2506. char *optstr;
  2507. long *typep;
  2508. {
  2509. if (streql(optstr, "all")) {
  2510. *typep = BLANK_DISC;
  2511. } else if (streql(optstr, "disc")) {
  2512. *typep = BLANK_DISC;
  2513. } else if (streql(optstr, "disk")) {
  2514. *typep = BLANK_DISC;
  2515. } else if (streql(optstr, "fast")) {
  2516. *typep = BLANK_MINIMAL;
  2517. } else if (streql(optstr, "minimal")) {
  2518. *typep = BLANK_MINIMAL;
  2519. } else if (streql(optstr, "track")) {
  2520. *typep = BLANK_TRACK;
  2521. } else if (streql(optstr, "unreserve")) {
  2522. *typep = BLANK_UNRESERVE;
  2523. } else if (streql(optstr, "trtail")) {
  2524. *typep = BLANK_TAIL;
  2525. } else if (streql(optstr, "unclose")) {
  2526. *typep = BLANK_UNCLOSE;
  2527. } else if (streql(optstr, "session")) {
  2528. *typep = BLANK_SESSION;
  2529. } else if (streql(optstr, "help")) {
  2530. blusage(0);
  2531. } else {
  2532. error("Illegal blanking type '%s'.n", optstr);
  2533. blusage(EX_BAD);
  2534. return (-1);
  2535. }
  2536. return (TRUE);
  2537. }