Copyright (c) 2000-2002 Craig Condit, Stefan Hülswitt.

 Copyright (c) 2000-2004 Craig Condit, Stefan Hülswitt.

 #include <linux/cdrom.h>

 #ifndef sun

 #include <getopt.h>

 #endif

 char * prg_name ="cdbackup";

 char *prg_name ="cdbackup";

 char * cd_dev   ="/dev/burner";

 char *cd_dev   ="/dev/burner";

 char * cdr_dev  =0;			/* no default here, too dangerous */

 char *cdr_dev  =0;                     /* no default here, too dangerous */

 char * cd_label ="CDBackup Track";

 char *cd_label ="CDBackup Track";

 int    cd_speed =4;

 int   cd_speed =4;

 long   cd_len   =333000;		/* blocks */

 long  cd_len   =-1;                    /* blocks */

 int    padsize  =15;			/* blocks */

 int   padsize  =15;                    /* blocks */

 int    multidisk=0;

 int   multidisk=0;

 char * multicmd =0;

 char *multicmd =0;

 int    verbose  =0;

 int   verbose  =0;

 int    xamode2  =0;

 int   xamode2  =0;

 int    debug    =0;

 int   crc      =1;

 int   debug    =0;

 int   virtual  =0;

 char *virt_name=0;

 int   virt_dump=0;

 int   dvd      =0;

 long long totalSize;

 long long totalSize=0;

 int disknum=1;

 int secs;

 int auto_size=0;

 /****************************************************************************/

 /****************************************************************************/

 void usage()

 {

 char *make_arg(const char *format, ...)

   fprintf(stderr,

 {

     "Usage: %s [options ...] [-- cdrecord-options ...]\n"

   char *ptr;

     "Reads from standard input, block formats and writes to CD-R(W).\n\n"

   va_list ap;

     "  -d DEVICE      DEVICE for CD queries (default /dev/burner)\n"

   va_start(ap,format);

     "  -l N           CD-R has a size of N MB (default 650)\n"

   if(vasprintf(&ptr,format,ap)<0) serror("No memory for cdrecord args\n");

     "  -r DEVICE      DEVICE for CD recording (e.g. 0,4,0)\n"

   va_end(ap);

     "  -s N           record CD at speed N (default 4)\n"

   return ptr;

     "  -X             enable CDROM XA2 mode in cdrecord\n"

 }

     "  -a LABEL       use LABEL as CD session title\n"

     "  -p N           use a padsize of N sectors for the session (default 15)\n"

 void start_cdrecord(void)

     "  -m             enable multi-disk mode\n"

 {

     "  -c COMMAND     call COMMAND on disk change in multi-disk mode\n"

   char **args, **p, *exname;

     "  -v             be verbose\n"

   int l;

     "  -D             enable DEBUG output\n"

     "  -V             prints version & exits\n"

   if(!(p=args=calloc(cdrec_opt_count+10,sizeof(char *))))

     "  --             pass rest of commandline to cdrecord\n"

     serror("No memory for cdrecord args\n");

     "\n", prg_name);

   if(dvd) exname="dvdrecord"; else exname="cdrecord";

   *p++=exname;

   if(virt_dump || dvd) {

     *p++="-dao";

     *p++=make_arg("tsize=%ds",secs);

     }

   else {

     *p++="-multi";

     *p++=make_arg("padsize=%ds",padsize);

     }

   *p++=make_arg("speed=%d",cd_speed);

   *p++=make_arg("dev=%s",cdr_dev);

   for(l=0 ; l<cdrec_opt_count ; l++) *p++=cdrec_opt[l];

   if(xamode2 && !dvd) *p++="-xa2"; else *p++="-data";

   *p++="-";

   *p++=0;

   if(debug) {

     fprintf(stderr,"%s: cdrecord command:",prg_name);

     for(p=args ; *p ; p++) fprintf(stderr," %s",*p);

     fprintf(stderr,"\n");

     }

   execvp(exname,args);

   error("Exec failed (cdrecord)");

 }

 long atip_cdrecord(void)

 {

   char *cmd;

   FILE *p;

   long size=-1;

   asprintf(&cmd,"%srecord 2>&1 dev=%s -atip",dvd ? "dvd":"cd",cdr_dev);

   DEBUG("%s: cdrecord atip command: %s\n",prg_name,cmd);

   p=popen(cmd,"r");

   if(!p) fprintf(stderr,"%s: atip command failed\n",prg_name);

   else {

     char buff[256];

     while(fgets(buff,sizeof(buff),p)) {

       if(dvd && !strncmp(buff,"rzone size:",11)) size=strtol(&buff[12],NULL,10);

       else if(!strncmp(buff,"  ATIP start of lead out:",25)) size=strtol(&buff[26],NULL,10);

       }

     }

   pclose(p);

   free(cmd);

   if(size>0 && verbose) {

     char buff[16];

     fprintf(stderr,"%s: auto-detected media size %s (%ld blocks)\n",prg_name,FlexSize(buff,(long long)size*CD_FRAMESIZE),size);

     }

   return size;

   char *val;

   while ((i=getopt(argc,argv,"d:r:l:s:p:a:c:mvVXD"))>0) {

   /* get some default from the environment */

   val=getenv("CDR_DEVICE");

   if(val) {

     cdr_dev=strdup(val);

     DEBUG("cdbackup: using recording device %s from CDR_DEVICE\n",cdr_dev);

     }

   val=getenv("CDR_SPEED");

   if(val) {

     cd_speed=strtol(val,NULL,10);

     DEBUG("cdbackup: using speed %d from CDR_SPEED\n",cd_speed);

     }

   while ((i=getopt(argc,argv,"d:r:l:s:p:a:c:mvVXDCi:wR"))>0) {

 	                        "Copyright (C) 2000-2002\n"

 	                        "Copyright (C) 2000-2004\n"

        case 'l': errno=0; cd_len=strtol(optarg,NULL,10);

        case 'l': cd_len=(long)(FlexLen(optarg)/CD_FRAMESIZE);

                  if(errno==ERANGE || cd_len<1) serror("Option -l: length out of range (must be >=1)\n");

                  break;

 	         cd_len = (long long)cd_len * (1024*1024) / CD_FRAMESIZE; /* convert to blocks */

 	         break;

        default:  usage(); exit(0);

        default:  fprintf(stderr,

                          "Usage: %s [options ...] [-- cdrecord-options ...]\n"

                          "Reads from standard input, block formats and writes to CD-R(W).\n\n"

                          "  -d DEVICE      DEVICE for CD queries (default /dev/burner)\n"

                          "  -l N           set media size, disable auto-detect\n"

                          "  -r DEVICE      DEVICE for CD recording (e.g. 0,4,0)\n"

                          "  -s N           record CD at speed N (default 4)\n"

                          "  -X             enable CDROM XA2 mode in cdrecord\n"

                          "  -a LABEL       use LABEL as CD session title\n"

                          "  -p N           use a padsize of N sectors for the session (default 15)\n"

                          "  -m             enable multi-disk mode\n"

                          "  -c COMMAND     call COMMAND on disk change in multi-disk mode\n"

                          "  -C             disable checksum creation for datablocks\n"

                          "  -i IMAGE       use virtual image IMAGE for recording\n"

                          "  -w             dump virtual image to media\n"

                          "  -R             enables DVD mode\n"

                          "  -v             be verbose\n"

                          "  -D             enable DEBUG output\n"

                          "  -V             prints version & exits\n"

                          "  --             pass rest of commandline to cdrecord\n"

                          "\n", prg_name);

                  exit(0);

   if(!cdr_dev) serror("You must specify a device for cdrecord with -r\n");

   if(cd_len<0) {

 }

     auto_size=1;

     if(virtual && !virt_dump) serror("Can't auto-detect media size in virtual mode. Use option -l to set media size\n");

 /****************************************************************************/

     }

   if(virtual && dvd && !virt_dump) {

 #define MARG(ptr,len,form,arg) { int l=(len);\

      fprintf(stderr,"Option -R ignored in virtual mode\n");

                                if(!(*ptr=(char *)malloc(l+1))) serror("No memory for cdrecord args\n");\

      dvd=0;

                                snprintf(*ptr++,l,form,arg);\

      }

                              }

   if(dvd) {

     if(xamode2) fprintf(stderr,"Option -X ignored in DVD mode\n");

 void start_cdrecord() 

     padsize=0;

 {

     }

   char **args, **p;

   if(virt_dump && !virtual) serror("To dump an image you must supply the image name with -i\n");

   int l;

   if(!cdr_dev && (!virtual || virt_dump)) serror("You must specify a device for cdrecord with -r\n");

 }

   if(!(p=args=calloc(cdrec_opt_count+8,sizeof(char *))))

     serror("No memory for cdrecord args\n");

 /****************************************************************************/

   *p++="cdrecord";

 void autosize(void)

   *p++="-multi";

 {

   MARG(p,16,"speed=%d",cd_speed);

   if(auto_size) {

   MARG(p,6+strlen(cdr_dev),"dev=%s",cdr_dev);

     cd_len=atip_cdrecord();

     if(cd_len<0) serror("Media size detection failed. Use option -l to set media size\n");

   for(l=0 ; l<cdrec_opt_count ; l++) *p++=cdrec_opt[l];

     }

 }

   MARG(p,20,"padsize=%ds",padsize);

   if(xamode2) *p++="-xa2"; else *p++="-data";

 /****************************************************************************/

   *p++="-";

   *p++=0;

 void dump(void)

 {

   if(debug) {

   int n, cont;

     fprintf(stderr,"%s: cdrecord command:",prg_name);

   char buffer[CD_FRAMESIZE];

     for(p=args ; *p ; p++) fprintf(stderr," %s",*p);

   long long grandTotal;

     fprintf(stderr,"\n");

     }

   do {

     int change;

   execvp("cdrecord",args);

     do {

   error("Unable to launch cdrecord");

       autosize();

 }

       virtual=1;

       Vopen(1); n=VreadToc(0);

 /****************************************************************************/

       if(n<1) serror("It's not usefull to dump an empty image");

       secs=Vsize(); cont=VhasCont();

 int backup(char disk_set)

       if(cd_avail<secs*CD_FRAMESIZE) serror("Image doesn't fits to media");

 {

       Vseek(-1); VprepareDump();

   pid_t childpid;

   int fd[2];

       virtual=0; change=0;

   int outpipe, bytes;

       Vopen(0); n=VreadToc(0); VprintSpace();

       if(n!=0) {

         fprintf(stderr,"Can't dump to non-empty disk! Try another disk\n");

         change=1;

         }

       if(change) {

         Vclose();

         diskchange(multicmd,cd_dev);

         }

       } while(change);

     if(verbose)

       fprintf(stderr,"%s: Dumping image (%d blocks) to %s\n",prg_name,secs,VdevName());

     VnewTrack();

     grandTotal=0;

     while(secs>0) {

       VvirtRead(buffer);

       Vwrite(buffer); grandTotal+=CD_FRAMESIZE;

       secs--;

       }

     VcloseTrack(0);

     totalSize+=grandTotal;

     if(verbose) {

       char str1[16], str2[16];

       fprintf(stderr,"%s: Dumping finished. %s written (%s on this disk)\n",

               prg_name,FlexSize(str1,totalSize),FlexSize(str2,grandTotal));

       }

     if(multidisk==0) {

       if(cont) fprintf(stderr,"Multi-disk not enabled, ignoring continuation image(s)!\n");

       cont=0;

       }

     else {

       disknum++;

       diskchange(multicmd,cd_dev);

       }

     } while(cont);

 }

 /****************************************************************************/

 int backup(void)

 {

   sprintf(buffer, "%04d%02d%02d%02d%02d", curtime.tm_year + 1900,

   flags=F_NONE;

     curtime.tm_mon + 1, curtime.tm_mday, curtime.tm_hour, curtime.tm_min);

   datasize=DATASIZE;

   if(crc) { flags|=F_CRC; datasize-=4; }

   sprintf(buffer,"%04d%02d%02d%02d%02d",curtime.tm_year+1900,

     curtime.tm_mon+1,curtime.tm_mday,curtime.tm_hour,curtime.tm_min);

   strncpy(header.id_str,HDR_STRING,32); header.id_str[32] = 0;

   strncpy(header.id_str,HDR_STRING,32); header.id_str[32]=0;

   strncpy(header.vol_id,cd_label,32); header.vol_id[32] = 0;

   strncpy(header.vol_id,cd_label,32); header.vol_id[32]=0;

   strncpy(header.t_stamp,buffer,12); header.t_stamp[12] = 0;

   strncpy(header.t_stamp,buffer,12); header.t_stamp[12]=0;

   header.disk_set = disk_set;

   header.disk_set = disknum;

   header.flags = flags;

     fprintf(stderr,"%s: Recording to device %s, multidisk %s, disk %d\n",prg_name,cdr_dev,multidisk?"enabled":"disabled",disk_set); 

     fprintf(stderr,"%s: Recording to %s, multidisk %s, CRC %s, disk %d\n",

             prg_name,VdevName(),

 #ifndef DEBUGOUT /* the "real" code */

             multidisk?"enabled":"disabled",

   /* launch cdrecord */

             crc?"enabled":"disabled",

   if(pipe(fd) == -1) error("Unable to create pipe handles");

             disknum); 

   if((childpid=fork()) == -1) error("Fork failed");

   secs=cd_len;

   if(childpid == 0) {        /* child */

   VnewTrack();

     close(fd[1]);

     close(0);		     /* stdin */

     dup2(fd[0], 0);

     start_cdrecord();        /* doesn't return */

     }

   close(fd[0]); outpipe=fd[1];

   /* output the header block */

   if((bytes=write(outpipe, buffer, CD_FRAMESIZE)) != CD_FRAMESIZE) error("Error writing header block");

   Vwrite(buffer); grandTotal+=CD_FRAMESIZE;

   cd_avail-=bytes; grandTotal+=bytes;

   /* account for the padsize */

   cd_avail-=padsize*CD_FRAMESIZE;

 #else

   /* debug code; send data to /dev/null.  Don't need the pipe. */

   fprintf(stderr, "DEBUG CODE: sending data to /dev/null!\n");

   outpipe = open("/dev/null", O_WRONLY);

   if (outpipe < 0) { perror("/dev/null"); exit(1); }

 #endif

   db->reserved = 0;

     /* read a block */

     int bytes;

     db->status = 0;		         /* this isn't the last block (for now) */

     bytes=full_read(0,&buffer[DBSIZE],DATASIZE);

     db->flags=flags;

     if (bytes < 0) error("Error reading input");

     db->status=0;		      /* this isn't the last block (for now) */

     if (bytes != DATASIZE) db->status=1; /* EOF, this is the last block */

     bytes=full_read(0,&buffer[DBSIZE],datasize);

     db->datasize = htons(bytes);

     if(bytes!=datasize) db->status=1; /* EOF, this is the last block */

     db->datasize=htons(bytes);

     /* check for free space */

     if(cd_avail < (CD_FRAMESIZE*2)) {	/* less than 2 block free */

     if(cd_avail<(CD_FRAMESIZE*2)) {   /* less than 2 block free */

       if(db->status==0) db->status=2;   /* if not last block, mark disk as full */

       if(db->status==0) {             /* if not last block, mark disk as full */

       }

         db->status=2;

         result=1;

     /* write a block */

         }

     bytes = write(outpipe, buffer, CD_FRAMESIZE);

       }

     if(bytes != CD_FRAMESIZE) error("Error writing data block");

     if(crc) {

       int l=crc32(buffer,bytes+DBSIZE);

     grandTotal+=bytes; cd_avail-=bytes;

       *((unsigned long *)(&buffer[CD_FRAMESIZE-4]))=l;

       }

     Vwrite(buffer); grandTotal+=CD_FRAMESIZE;

   /* close pipe and wait for child termination */

   if(dvd && cd_avail>=CD_FRAMESIZE) { /* pad up the track with zeros */

   close(outpipe);

     memset(buffer,0,CD_FRAMESIZE);

   while (wait(0) != childpid);

     if(verbose) fprintf(stderr,"%s: padding up the track\n",prg_name);

     while(cd_avail>=CD_FRAMESIZE) Vwrite(buffer);

     }

   VcloseTrack(result);

   if(verbose) fprintf(stderr,"%s: Recording finished. %lld kB written (%lld kB on this disk)\n",

   if(verbose) {

                       prg_name,totalSize/1024,grandTotal/1024);

     char str1[16], str2[16];

     fprintf(stderr,"%s: Recording finished. %s written (%s on this disk)\n",

   if(db->status==2) return 1; /* disk was full */

             prg_name,FlexSize(str1,totalSize),FlexSize(str2,grandTotal));

     }

   return result;

 }

 /****************************************************************************/

 int main(int argc, char *argv[]) 

 {

   int result, loop;

   time_t curtime_t;

   curtime_t=time(0); curtime=*localtime(&curtime_t);

   parse_cmdline(argc,argv);

   if(virt_dump) {

     dump();

     }

   else {

     do {

       do {

         autosize();

         Vopen(0); result=VreadToc(0); VprintSpace();

         loop=1;

         if(disknum>1 && result!=0) {

           Vclose();

           fprintf(stderr,"%s: Can't do multidisk continuation on non-empty disk! Try another disk\n", prg_name);

           diskchange(multicmd,cd_dev);

           }

         else if(cd_avail<(padsize+MIN_BLOCKS)*CD_FRAMESIZE) {

           Vclose();

           if(multidisk) {

             fprintf(stderr,"%s: Not enough free space on disk! Try another disk\n", prg_name);

             diskchange(multicmd,cd_dev);

             }

           else serror("Not enough free space on disk");

           }

         else loop=0;

         } while(loop);

       result=backup();

       if(result==1) {

         if(multidisk==0) serror("Disk full, multi-disk not enabled. Aborting");

         disknum++;

         if(!VisRegular()) diskchange(multicmd,cd_dev);

         }

       } while(result!=0);

     }