home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / misc / tape-handler.lzh / TAPEDEV.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-10  |  15.2 KB  |  556 lines
  1. /*
  2.  * tapedev.c - by Markus Wandel - 1990
  3.  * Placed in the public domain 7 Oct 1990
  4.  * Please have the courtesy to give credit
  5.  * if you use this code in any program.
  6.  *
  7.  */
  8.  
  9. #include <exec/ports.h>
  10. #include <exec/io.h>
  11. #include <devices/scsidisk.h>
  12. #include <libraries/dos.h>
  13. #include <libraries/dosextens.h>
  14. #include <libraries/filehandler.h>
  15.  
  16. #define CLOSED 0
  17. #define JUST_OPENED 1
  18. #define OPEN_FOR_READ 2
  19. #define OPEN_FOR_WRITE 3
  20.  
  21. #define SCSI_OK 0
  22. #define SCSI_ERROR 1
  23. #define SCSI_UNIT_ATTENTION 2
  24. #define SCSI_FILEMARK 3
  25.  
  26. #define UNKNOWN 0
  27. #define REWOUND 1
  28. #define IN_FILE 2
  29. #define AT_FILEMARK 3
  30. #define AT_END 4
  31.  
  32. #define ACT_FINDINPUT 1005
  33. #define ACT_FINDOUTPUT 1006
  34. #define ACT_END 1007
  35.  
  36. extern void *FindTask();
  37. extern struct DosPacket *taskwait();
  38. extern struct MsgPort *CreatePort();
  39. extern struct IOStdReq *CreateStdIO();
  40. extern long OpenDevice();
  41. extern void *OpenLibrary();
  42. extern int AutoAutoRequest();
  43. extern void *malloc();
  44.  
  45. unsigned long buffer_size;
  46. unsigned long buffer_cutoff;
  47. long unitnum;
  48. long flags;
  49. char *devname;
  50. int devlength;
  51.  
  52. struct MsgPort *mp;
  53. struct IOStdReq *iob;
  54. struct Process *myproc;
  55. int tapestate;
  56. int errnum;
  57. ULONG buffer_highmark;
  58. ULONG buffer_current;
  59. int read_eof;
  60. struct SCSICmd cmd;
  61. ULONG actual;
  62. void *IntuitionBase;
  63. int notified;
  64.  
  65. UBYTE sense_cmd[] = { 3,0,0,0,20,0 };
  66. UBYTE rewind_cmd[] = { 1,0,0,0,0,0 };
  67. UBYTE test_ready_cmd[] = { 0,0,0,0,0,0 };
  68. UBYTE skip_filemark_cmd[] = { 0x11,1,0,0,1,0 };
  69. UBYTE skip_end_cmd[] = {0x11,3,0,0,1,0 };
  70. UBYTE write_filemark_cmd[] = {0x10,0,0,0,1,0};
  71. UBYTE mode_sense_cmd[] = {0x1a,0,0,0,3,0};
  72.  
  73. UBYTE *buffer;
  74. UBYTE sensebuf[20];
  75.  
  76. _main()
  77. {
  78.     register struct DosPacket *pkt;
  79.     struct DeviceNode *devnode;
  80.     register int openstate;
  81.     UBYTE *ptr;
  82.     int i;
  83.     long error;
  84.  
  85.     myproc = (struct Process *)FindTask(0L);
  86.     pkt = taskwait(myproc);
  87.     devnode = (struct DeviceNode *) ((pkt->dp_Arg3)<<2);
  88.  
  89.     if(parsestartup((pkt->dp_Arg2)<<2) || buffer_size < 10) {
  90.         returnpkt(pkt,myproc,DOSFALSE,ERROR_NO_FREE_STORE);
  91.         return 0;
  92.     }
  93.  
  94.     buffer_cutoff = buffer_size << 8;
  95.     buffer_size <<= 9;
  96.  
  97.     buffer = (UBYTE *)malloc(buffer_size);
  98.     if(!buffer) {
  99.         returnpkt(pkt,myproc,DOSFALSE,ERROR_NO_FREE_STORE);
  100.         return 0;
  101.     }
  102.  
  103.     IntuitionBase = OpenLibrary("intuition.library",0L);
  104.  
  105.     if(!IntuitionBase) {
  106.         returnpkt(pkt,myproc,DOSFALSE,ERROR_NO_FREE_STORE);
  107.         free(buffer);
  108.         return 0;
  109.     }
  110.  
  111.     mp = CreatePort(0L,0L);
  112.     if(!mp) {
  113.         returnpkt(pkt,myproc,DOSFALSE,ERROR_NO_FREE_STORE);
  114.         CloseLibrary(IntuitionBase);
  115.         free(buffer);
  116.         return 0;
  117.     }
  118.     iob = CreateStdIO(mp);
  119.     if(!iob) {
  120.         CloseLibrary(IntuitionBase);
  121.         free(buffer);
  122.         DeletePort(mp);
  123.         returnpkt(pkt,myproc,DOSFALSE,ERROR_NO_FREE_STORE);
  124.         return 0;
  125.     }
  126.  
  127.     devname[devlength] = 0;
  128.     error = OpenDevice(devname,unitnum,iob,flags);
  129.     devname[devlength] = '/';
  130.  
  131.     if(error) {
  132.         CloseLibrary(IntuitionBase);
  133.         free(buffer);
  134.         DeleteStdIO(iob);
  135.         DeletePort(mp);
  136.         returnpkt(pkt,myproc,DOSFALSE,ERROR_OBJECT_NOT_FOUND);
  137.         return 0;
  138.     }
  139.  
  140.     devnode->dn_Task = &myproc->pr_MsgPort;
  141.     returnpkt(pkt,myproc,DOSTRUE,0L);
  142.  
  143.     openstate = CLOSED;
  144.     tapestate = UNKNOWN;
  145.  
  146.     for(;;) {
  147.         pkt = taskwait(myproc);
  148.         switch(pkt->dp_Type) {
  149.             case ACT_FINDINPUT:
  150.             case ACT_FINDOUTPUT:
  151.                 if(openstate != CLOSED) returnpkt(pkt,myproc,DOSFALSE,
  152.                                        ERROR_OBJECT_IN_USE);
  153.                 else if(not_ready()) {
  154.                     returnpkt(pkt,myproc,DOSFALSE,ERROR_OBJECT_NOT_FOUND);
  155.                 } else {
  156.                     errnum = 0;
  157.                     notified = 0;
  158.                     openstate = JUST_OPENED;
  159.                     ptr = (UBYTE *) ((pkt->dp_Arg3)<<2);
  160.                     for(i=*ptr++;i>1;i--) {
  161.                         if(*ptr++ == ':') {
  162.                             if(*ptr == 'R' || *ptr == 'r')
  163.                                 rewind();
  164.                             else if(*ptr == 'A' || *ptr == 'a')
  165.                                 append();
  166.                             i=0;
  167.                         }
  168.                     }
  169.                     if(tapestate == UNKNOWN) rewind();
  170.                     returnpkt(pkt,myproc,DOSTRUE,0L);
  171.                 }
  172.                 break;
  173.             case ACTION_READ:
  174.                 switch(openstate) {
  175.                     case JUST_OPENED:
  176.                         init_read();
  177.                         openstate = OPEN_FOR_READ;
  178.                     case OPEN_FOR_READ:
  179.                         tape_read(pkt);
  180.                         break;
  181.                     default:
  182.                         returnpkt(pkt,myproc,-1L,ERROR_READ_PROTECTED);
  183.                 }
  184.                 break;
  185.             case ACTION_WRITE:
  186.                 switch(openstate) {
  187.                     case JUST_OPENED:
  188.                         init_write();
  189.                         openstate = OPEN_FOR_WRITE;
  190.                     case OPEN_FOR_WRITE:
  191.                         tape_write(pkt);
  192.                         break;
  193.                     default:
  194.                         returnpkt(pkt,myproc,-1L,ERROR_OBJECT_NOT_FOUND);
  195.                 }
  196.                 break;
  197.             case ACT_END:
  198.                 if(openstate == OPEN_FOR_WRITE) finish_write();
  199.                 openstate = CLOSED;
  200.                 returnpkt(pkt,myproc,DOSTRUE,0L);
  201.                 break;
  202.             default:
  203.                 returnpkt(pkt,myproc,DOSFALSE,(long)ERROR_ACTION_NOT_KNOWN);
  204.         }
  205.     }
  206. }
  207.  
  208. /*
  209.  *  This function is called for every open and tests if a tape is ready.
  210.  *
  211.  *  tapestate becomes UNKNOWN if no tape is ready.
  212.  *
  213.  */
  214. not_ready()
  215. {
  216.     do {
  217.         switch(doscsi(0L,test_ready_cmd,0L,6,1)) {
  218.             case SCSI_OK:
  219.                 return 0;
  220.             case SCSI_UNIT_ATTENTION:
  221.                 if(doscsi(0L,test_ready_cmd,0L,6,1)==SCSI_OK) return 0;
  222.             default:
  223.                 tapestate = UNKNOWN;
  224.         }
  225.     } while(AutoAutoRequest("Tape unit not ready.",0L,0L,"Retry","Cancel"));
  226.     return -1;
  227. }
  228.  
  229. rewind()
  230. {
  231.     if(doscsi(0L,rewind_cmd,0L,6,1))
  232.         errnum = ERROR_OBJECT_NOT_FOUND;
  233.     else tapestate = REWOUND;
  234. }
  235.  
  236. append()
  237. {
  238.     if(doscsi(0L,skip_end_cmd,0L,6,1))
  239.         errnum = ERROR_OBJECT_NOT_FOUND;
  240.     else tapestate = AT_END;
  241. }
  242.  
  243. init_read()
  244. {
  245.     int i;
  246.     buffer_current = 0;
  247.     buffer_highmark = 0;
  248.     read_eof = 0;
  249.     if(!errnum) switch(tapestate) {
  250.         case IN_FILE:
  251.             if(doscsi(0L,skip_filemark_cmd,0L,6,1)) {
  252.                 tapestate = UNKNOWN;
  253.                 errnum = ERROR_OBJECT_NOT_FOUND;
  254.             }
  255.             tapestate = AT_FILEMARK;
  256.         case AT_FILEMARK:
  257.         case REWOUND:
  258.             break;
  259.         default:
  260.             errnum = ERROR_OBJECT_NOT_FOUND;
  261.     }
  262. }
  263.  
  264. init_write()
  265. {
  266.     UBYTE msbuf[3];
  267.     buffer_current = 0;
  268.     if(!errnum) switch(tapestate) {
  269.         case AT_FILEMARK:
  270.         case IN_FILE:
  271.             if(doscsi(0L,skip_end_cmd,0L,6,1)) {
  272.                 errnum = ERROR_OBJECT_NOT_FOUND;
  273.                 tapestate = UNKNOWN;
  274.             }
  275.         case AT_END:
  276.         case REWOUND:
  277.             if(doscsi(msbuf,mode_sense_cmd,3L,6,1)) {
  278.                 errnum = ERROR_OBJECT_NOT_FOUND;
  279.                 return;
  280.             }
  281.             if(msbuf[2] & 0x80) {
  282.                 errnum = ERROR_OBJECT_NOT_FOUND;
  283.                 AutoAutoRequest("Tape is write protected.",0L,0L,0L,"Abort");
  284.                 notified = 1;
  285.                 return;
  286.             }
  287.             break;
  288.         default:
  289.             errnum = ERROR_OBJECT_NOT_FOUND;
  290.     }
  291. }
  292.  
  293. char readerr1[] = "An error has occurred while";
  294. char readerr2[] = "trying to read from the tape.";
  295.  
  296. tape_read(pkt)
  297. register struct DosPacket *pkt;
  298. {
  299.     register UBYTE *ptr = (UBYTE *)pkt->dp_Arg2;
  300.     register ULONG length = pkt->dp_Arg3;
  301.     register ULONG fragment;
  302.     UBYTE cmdbuf[6];
  303.  
  304.     if(errnum) {
  305.         if(!notified) {
  306.             AutoAutoRequest(readerr1,readerr2,0L,0L," OK ");
  307.             notified = 1;
  308.         }
  309.         returnpkt(pkt,myproc,-1L,(long)errnum);
  310.         return;
  311.     }
  312.     /*
  313.      *  First, transfer whatever is left in the buffer.
  314.      */
  315.     if(buffer_current < buffer_highmark ) {
  316.         fragment = buffer_highmark - buffer_current;
  317.         if(length<fragment) fragment = length;
  318.         CopyMem(buffer+buffer_current,ptr,fragment);
  319.         length -= fragment;
  320.         buffer_current += fragment;
  321.         ptr += fragment;
  322.     }
  323.     if(!read_eof) {
  324.         if(length>buffer_cutoff) {
  325.             fragment = length & ~511;
  326.             cmdbuf[0] = 8;
  327.             cmdbuf[1] = 1;
  328.             *((ULONG *)&cmdbuf[2]) = fragment>>1;
  329.             switch(doscsi(ptr,cmdbuf,fragment,6,1)) {
  330.                 case SCSI_FILEMARK:
  331.                     fragment = actual;
  332.                     read_eof = 1;
  333.                     break;
  334.                 case SCSI_OK:
  335.                     tapestate = IN_FILE;
  336.                     break;
  337.                 default:
  338.                     read_eof = 1;
  339.                     fragment = 0;
  340.                     AutoAutoRequest(readerr1,readerr2,0L,0L," OK ");
  341.                     notified = 1;
  342.                     break;
  343.             }
  344.             ptr += fragment;
  345.             length -= fragment;
  346.         }
  347.         if(length && !read_eof) {
  348.             cmdbuf[0] = 8;
  349.             cmdbuf[1] = 1;
  350.             *((ULONG *)&cmdbuf[2]) = buffer_size>>1;
  351.             switch(doscsi(buffer,cmdbuf,(long)buffer_size,6,1)) {
  352.                 case SCSI_FILEMARK:
  353.                     read_eof = 1;
  354.                     buffer_highmark = actual;
  355.                     break;
  356.                 case SCSI_OK:
  357.                     buffer_highmark = actual;
  358.                     tapestate = IN_FILE;
  359.                     break;
  360.                 default:
  361.                     read_eof = 1;
  362.                     buffer_highmark = 0;
  363.                     AutoAutoRequest(readerr1,readerr2,0L,0L," OK ");
  364.                     notified = 1;
  365.                     errnum = ERROR_SEEK_ERROR;
  366.             }
  367.             buffer_current = length;
  368.             if(buffer_highmark < buffer_current) buffer_current = buffer_highmark;
  369.             CopyMem(buffer,ptr,buffer_current);
  370.             length -= buffer_current;
  371.         }
  372.     }
  373.     if(errnum) if(pkt->dp_Arg3==length) {
  374.         returnpkt(pkt,myproc,-1L,ERROR_SEEK_ERROR);
  375.         return;
  376.     }
  377.     returnpkt(pkt,myproc,pkt->dp_Arg3-length,0L);
  378. }
  379.  
  380. char writerr1[] = "An error has occurred while";
  381. char writerr2[] = "trying to write to the tape.";
  382. char writerr3[] = "Tape data is probably invalid.";
  383.  
  384. tape_write(pkt)
  385. register struct DosPacket *pkt;
  386. {
  387.     register UBYTE *ptr = (UBYTE *)pkt->dp_Arg2;
  388.     register ULONG length = pkt->dp_Arg3;
  389.     register ULONG fragment;
  390.     UBYTE cmdbuf[6];
  391.  
  392.     if(errnum) {
  393.         if(!notified) {
  394.             AutoAutoRequest(writerr1,writerr2,writerr3,0L," OK ");
  395.             notified = 1;
  396.         }
  397.         returnpkt(pkt,myproc,-1L,(long)errnum);
  398.         return;
  399.     }
  400.     if(buffer_current || (length <= buffer_cutoff)) {
  401.         fragment = buffer_size - buffer_current;
  402.         if(length < fragment) fragment = length;
  403.         CopyMem(ptr,buffer+buffer_current,fragment);
  404.         ptr += fragment;
  405.         buffer_current += fragment;
  406.         length -= fragment;
  407.         /*
  408.          *  If the buffer is full, flush it.
  409.          *
  410.          */
  411.         if(buffer_current == buffer_size) {
  412.             cmdbuf[0] = 10;
  413.             cmdbuf[1] = 1;
  414.             *((ULONG *)&cmdbuf[2]) = buffer_size>>1;
  415.             if(doscsi(buffer,cmdbuf,(long)buffer_size,6,0)) {
  416.                 AutoAutoRequest(writerr1,writerr2,writerr3,0L," OK ");
  417.                 notified = 1;
  418.                 errnum = ERROR_SEEK_ERROR;
  419.             }
  420.             buffer_current = 0;
  421.         }
  422.     }
  423.     if(!errnum) {
  424.         if(length>buffer_cutoff) {
  425.             fragment = length & ~511;
  426.             cmdbuf[0] = 10;
  427.             cmdbuf[1] = 1;
  428.             *((ULONG *)&cmdbuf[2]) = fragment>>1;
  429.             if(doscsi(ptr,cmdbuf,fragment,6,0)) {
  430.                 AutoAutoRequest(writerr1,writerr2,writerr3,0L," OK ");
  431.                 notified = 1;
  432.                 errnum = ERROR_SEEK_ERROR;
  433.             }
  434.             length -= fragment;
  435.             ptr += fragment;
  436.         }
  437.         if(length && !errnum) {
  438.             CopyMem(ptr,buffer,length);
  439.             buffer_current = length;
  440.             length = 0;
  441.         }
  442.     }
  443.     if(errnum)
  444.         returnpkt(pkt,myproc,-1L,ERROR_SEEK_ERROR);
  445.     else
  446.         returnpkt(pkt,myproc,pkt->dp_Arg3,0L);
  447. }
  448.  
  449. finish_write()
  450. {
  451.     UBYTE cmdbuf[6];
  452.     ULONG fragment;
  453.  
  454.     if(buffer_current && !errnum) {
  455.         fragment = (buffer_current + 511) & ~511;
  456.         while(buffer_current < fragment) buffer[buffer_current++] = 0;
  457.         cmdbuf[0] = 10;
  458.         cmdbuf[1] = 1;
  459.         *((ULONG *)&cmdbuf[2]) = fragment>>1;
  460.         if(doscsi(buffer,cmdbuf,fragment,6,0))
  461.             AutoAutoRequest(writerr1,writerr2,writerr3,0L," OK ");
  462.             notified = 1;
  463.     }
  464.     if(doscsi(0L,write_filemark_cmd,0L,6,1)) {
  465.         if(!notified) AutoAutoRequest(writerr1,writerr2,writerr3,0L," OK ");
  466.     } else
  467.         tapestate = AT_END;
  468. }
  469.  
  470.  
  471. int doscsi(buf,cmdbuf,length,cmdlength,flags)
  472. UWORD *buf;
  473. UBYTE *cmdbuf;
  474. ULONG length;
  475. int cmdlength,flags;
  476. {
  477.     cmd.scsi_Data = buf;
  478.     cmd.scsi_Length = length;
  479.     cmd.scsi_CmdLength = cmdlength;
  480.     cmd.scsi_Flags = flags;
  481.     cmd.scsi_Command = cmdbuf;
  482.     iob->io_Command = 28;
  483.     iob->io_Data = (APTR) &cmd;
  484.     iob->io_Length = sizeof(cmd);
  485.     DoIO(iob);
  486.     actual = cmd.scsi_Actual;
  487.     switch(iob->io_Error) {
  488.         case 0:
  489.             if(length == actual) return SCSI_OK;
  490.             else return SCSI_ERROR;
  491.         case HFERR_BadStatus:
  492.             cmd.scsi_Command = sense_cmd;
  493.             cmd.scsi_Flags = 1;
  494.             cmd.scsi_CmdLength = 6;
  495.             cmd.scsi_Length = 20;
  496.             cmd.scsi_Data = (UWORD *) sensebuf;
  497.             DoIO(iob);
  498.             if(iob->io_Error) return SCSI_ERROR;
  499.             if(cmd.scsi_Actual > 4) {
  500.                 if(sensebuf[2] == 1 && actual == length) {
  501.                     return SCSI_OK;
  502.                 }
  503.                 if(sensebuf[2] == 6) {
  504.                     tapestate = UNKNOWN;
  505.                     return SCSI_UNIT_ATTENTION;
  506.                 }
  507.                 if(sensebuf[2] == 8) {
  508.                     tapestate = AT_END;
  509.                     return SCSI_ERROR;
  510.                 }
  511.                 if(sensebuf[2] == 0x80) {
  512.                     tapestate = AT_FILEMARK;
  513.                     return SCSI_FILEMARK;
  514.                 }
  515.             }
  516.         default:
  517.             tapestate = UNKNOWN;
  518.             return SCSI_ERROR;
  519.     }
  520. }
  521.  
  522. int parsestartup(msg)
  523. register char *msg;
  524. {
  525.     register int i,state = 0;
  526.  
  527.     buffer_size = 0;
  528.     unitnum = 0;
  529.     flags = 0 ;
  530.  
  531.     if(!msg) return 1;
  532.  
  533.     for(i=1;i<=msg[0];i++) {
  534.         if(msg[i] == '/') {
  535.             switch(++state) {
  536.                 case 1: devname = &msg[i+1];
  537.                         break;
  538.                 case 2: devlength = (&msg[i]) - devname;
  539.                         break;
  540.                 case 4:
  541.                         return 1;
  542.             }
  543.         } else if(state != 1) {
  544.             if(msg[i] < '0' || msg[i] > '9') return 1;
  545.             switch(state) {
  546.                 case 0: buffer_size = 10 * buffer_size + msg[i] - '0';
  547.                         break;
  548.                 case 2: unitnum = 10 * unitnum + msg[i] - '0';
  549.                         break;
  550.                 case 3: flags = 10 * flags + msg[i] - '0';
  551.             }
  552.         }
  553.     }
  554.     return (state<3);
  555. }
  556.