workbench/c/CopyToPAR.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Copy file to parallel.device
   6     Lang: English
   7 */
   8 /*****************************************************************************
   9
  10     NAME
  11
  12         CopyToPAR
  13
  14     SYNOPSIS
  15
  16         FILE/A,USB/S,QUIET/S
  17
  18     LOCATION
  19
  20         C:
  21
  22     FUNCTION
  23
  24         Copies (or sends) a file to parallel.device or usbparallel.device.
  25
  26     INPUTS
  27
  28         FILE   --  Either a file, a directory or a pattern to match.
  29
  30         USB    --  Use usbparallel.device.
  31
  32         QUIET  --  Suppresses any output to the shell.
  33
  34     RESULT
  35
  36         Standard DOS return codes.
  37
  38     NOTES
  39
  40     BUGS
  41
  42     INTERNALS
  43
  44 ******************************************************************************/
  45 #include <exec/io.h>
  46 #include <dos/dos.h>
  47 #include <devices/parallel.h>
  48 #include <proto/exec.h>
  49 #include <proto/dos.h>
  50
  51 /****************************************************************************************/
  52
  53 #define ARG_TEMPLATE        "FILE/A,USB/S,QUIET/S"
  54 #define ARG_FILE            0
  55 #define ARG_USB             1
  56 #define ARG_QUIET           2
  57 #define NUM_ARGS            3
  58
  59 #define BUFSIZE             4096
  60
  61 /****************************************************************************************/
  62
  63 struct MsgPort  *ParMP;
  64 struct IOStdReq *ParIO;
  65 BOOL             ParOpen;
  66 BPTR             fh;
  67 struct RDArgs   *myargs;
  68 IPTR             args[NUM_ARGS];
  69 UBYTE            s[256];
  70 UBYTE            buf[BUFSIZE];
  71 STRPTR           devicename = "parallel.device";
  72
  73 /****************************************************************************************/
  74
  75 static void cleanup(char *msg)
  76 {
  77     if (msg && !args[ARG_QUIET])
  78     {
  79         Printf("CopyToPAR: %s\n", msg);
  80     }
  81
  82     if (fh) Close(fh);
  83     if (myargs) FreeArgs(myargs);
  84
  85     if (ParOpen) CloseDevice((struct IORequest *)ParIO);
  86     if (ParIO) DeleteIORequest((struct IORequest *)ParIO);
  87     if (ParMP) DeleteMsgPort(ParMP);
  88 }
  89
  90 /****************************************************************************************/
  91
  92 static ULONG getarguments(void)
  93 {
  94     if (!(myargs = ReadArgs(ARG_TEMPLATE, args, 0)))
  95     {
  96         Fault(IoErr(), 0, s, 255);
  97         cleanup(s);
  98         return RETURN_FAIL;
  99     }
 100     return 0;
 101 }
 102
 103 /****************************************************************************************/
 104
 105 static ULONG openpar(void)
 106 {
 107     ParMP = CreateMsgPort();
 108     if (!ParMP)
 109     {
 110         cleanup("Failed to create msgport");
 111         return RETURN_ERROR;
 112     }
 113
 114     ParIO = (struct IOStdReq *)CreateIORequest(ParMP, sizeof(struct IOExtPar));
 115     if (!ParIO)
 116     {
 117         cleanup("Failed to create IO request");
 118         return RETURN_ERROR;
 119     }
 120
 121     if (args[ARG_USB])
 122     {
 123         devicename = "usbparallel.device";
 124     }
 125
 126     if (OpenDevice(devicename, 0, (struct IORequest *)ParIO, 0))
 127     {
 128         cleanup("Failed to open (usb)parallel.device");
 129         return RETURN_ERROR;
 130     }
 131
 132     ParOpen = TRUE;
 133     return 0;
 134 }
 135
 136 /****************************************************************************************/
 137
 138 static ULONG openfile(void)
 139 {
 140     fh = Open((STRPTR)args[ARG_FILE], MODE_OLDFILE);
 141     if (!fh)
 142     {
 143         Fault(IoErr(), 0, s, 255);
 144         cleanup(s);
 145         return RETURN_FAIL;
 146     }
 147     return 0;
 148 }
 149
 150 /****************************************************************************************/
 151
 152 static BOOL WritePAR(APTR buf, ULONG size)
 153 {
 154     ParIO->io_Command = CMD_WRITE;
 155     ParIO->io_Data    = buf;
 156     ParIO->io_Length  = size;
 157
 158     return (DoIO((struct IORequest *)ParIO) == 0) ? TRUE : FALSE;
 159 }
 160
 161 /****************************************************************************************/
 162
 163 static ULONG docopy(void)
 164 {
 165     LONG size;
 166
 167     do
 168     {
 169         size = Read(fh, buf, BUFSIZE);
 170         if (size == -1)
 171         {
 172             Fault(IoErr(), 0, s, 255);
 173             cleanup(s);
 174             return RETURN_FAIL;
 175         }
 176
 177         if (!WritePAR(buf, size))
 178         {
 179             cleanup("Error writing to (usb)parallel.device");
 180             return RETURN_FAIL;
 181         }
 182
 183     } while (size == BUFSIZE);
 184
 185     return 0;
 186 }
 187
 188 /****************************************************************************************/
 189
 190 int main(void)
 191 {
 192     int rc;
 193
 194     rc = getarguments();
 195     if (rc)
 196         return rc;
 197
 198     rc = openpar();
 199     if (rc)
 200         return rc;
 201
 202     rc = openfile();
 203     if (rc)
 204         return rc;
 205
 206     rc = docopy();
 207     if (rc)
 208         return rc;
 209
 210     cleanup(NULL);
 211     return 0;
 212 }