workbench/c/CopyToPAR.c

   1 /*
   2     Copyright © 1995-2010, 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 #include <stdlib.h>
  52 #include <stdio.h>
  53
  54 /****************************************************************************************/
  55
  56 #define ARG_TEMPLATE        "FILE/A,USB/S,QUIET/S"
  57 #define ARG_FILE            0
  58 #define ARG_USB             1
  59 #define ARG_QUIET           2
  60 #define NUM_ARGS            3
  61
  62 #define BUFSIZE             4096
  63
  64 /****************************************************************************************/
  65
  66 struct MsgPort  *ParMP;
  67 struct IOStdReq *ParIO;
  68 BOOL             ParOpen;
  69 BPTR             fh;
  70 struct RDArgs   *myargs;
  71 IPTR             args[NUM_ARGS];
  72 UBYTE            s[256];
  73 UBYTE            buf[BUFSIZE];
  74 STRPTR           devicename = "parallel.device";
  75
  76 /****************************************************************************************/
  77
  78 static void cleanup(char *msg, ULONG retcode)
  79 {
  80     if (msg && !args[ARG_QUIET])
  81     {
  82         fprintf(stderr, "CopyToPAR: %s\n", msg);
  83     }
  84
  85     if (fh) Close(fh);
  86     if (myargs) FreeArgs(myargs);
  87
  88     if (ParOpen) CloseDevice((struct IORequest *)ParIO);
  89     if (ParIO) DeleteIORequest((struct IORequest *)ParIO);
  90     if (ParMP) DeleteMsgPort(ParMP);
  91
  92     exit(retcode);
  93 }
  94
  95 /****************************************************************************************/
  96
  97 static void getarguments(void)
  98 {
  99     if (!(myargs = ReadArgs(ARG_TEMPLATE, args, 0)))
 100     {
 101         Fault(IoErr(), 0, s, 255);
 102         cleanup(s, RETURN_FAIL);
 103     }
 104 }
 105
 106 /****************************************************************************************/
 107
 108 static void openpar(void)
 109 {
 110     ParMP = CreateMsgPort();
 111     if (!ParMP) cleanup("Failed to create msgport", RETURN_ERROR);
 112
 113     ParIO = (struct IOStdReq *)CreateIORequest(ParMP, sizeof(struct IOExtPar));
 114     if (!ParIO) cleanup("Failed to create IO request", RETURN_ERROR);
 115
 116     if (args[ARG_USB])
 117     {
 118         devicename = "usbparallel.device";
 119     }
 120
 121     if (OpenDevice(devicename, 0, (struct IORequest *)ParIO, 0))
 122     {
 123         cleanup("Failed to open (usb)parallel.device", RETURN_ERROR);
 124     }
 125
 126     ParOpen = TRUE;
 127 }
 128
 129 /****************************************************************************************/
 130
 131 static void openfile(void)
 132 {
 133     fh = Open((STRPTR)args[ARG_FILE], MODE_OLDFILE);
 134     if (!fh)
 135     {
 136         Fault(IoErr(), 0, s, 255);
 137         cleanup(s, RETURN_FAIL);
 138     }
 139 }
 140
 141 /****************************************************************************************/
 142
 143 static BOOL WritePAR(APTR buf, ULONG size)
 144 {
 145     ParIO->io_Command = CMD_WRITE;
 146     ParIO->io_Data    = buf;
 147     ParIO->io_Length  = size;
 148
 149     return (DoIO((struct IORequest *)ParIO) == 0) ? TRUE : FALSE;
 150 }
 151
 152 /****************************************************************************************/
 153
 154 static void docopy(void)
 155 {
 156     LONG size;
 157
 158     do
 159     {
 160         size = Read(fh, buf, BUFSIZE);
 161         if (size == -1)
 162         {
 163             Fault(IoErr(), 0, s, 255);
 164             cleanup(s, RETURN_FAIL);
 165         }
 166
 167         if (!WritePAR(buf, size))
 168         {
 169             cleanup("Error writing to (usb)parallel.device", RETURN_FAIL);
 170         }
 171
 172     } while (size == BUFSIZE);
 173
 174 }
 175
 176 /****************************************************************************************/
 177
 178 int main(void)
 179 {
 180     getarguments();
 181     openpar();
 182     openfile();
 183     docopy();
 184     cleanup(NULL, 0);
 185
 186     return 0;
 187 }