workbench/c/CopyToPAR.c

   1 /*
   2     Copyright © 1995-2001, 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,QUIET/S
  17
  18     LOCATION
  19
  20         Sys:c
  21
  22     FUNCTION
  23
  24         Copies (or sends a) file to parallel.device.
  25
  26     INPUTS
  27
  28         FILE   --  Either a file, a directory or a pattern to match.
  29
  30         QUIET  --  Suppresses any output to the shell.
  31
  32     RESULT
  33
  34         Standard DOS return codes.
  35
  36     NOTES
  37
  38     BUGS
  39
  40     INTERNALS
  41
  42 ******************************************************************************/
  43 #include <exec/io.h>
  44 #include <dos/dos.h>
  45 #include <devices/parallel.h>
  46 #include <proto/exec.h>
  47 #include <proto/dos.h>
  48
  49 #include <stdlib.h>
  50 #include <stdio.h>
  51
  52 /****************************************************************************************/
  53
  54 #define ARG_TEMPLATE        "FILE/A,QUIET/S"
  55 #define ARG_FILE            0
  56 #define ARG_QUIET           1
  57 #define NUM_ARGS            2
  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
  72 /****************************************************************************************/
  73
  74 static void cleanup(char *msg, ULONG retcode)
  75 {
  76     if (msg && !args[ARG_QUIET])
  77     {
  78         fprintf(stderr, "CopyToPAR: %s\n", msg);
  79     }
  80
  81     if (fh) Close(fh);
  82     if (myargs) FreeArgs(myargs);
  83
  84     if (ParOpen) CloseDevice((struct IORequest *)ParIO);
  85     if (ParIO) DeleteIORequest((struct IORequest *)ParIO);
  86     if (ParMP) DeleteMsgPort(ParMP);
  87
  88     exit(retcode);
  89 }
  90
  91 /****************************************************************************************/
  92
  93 static void getarguments(void)
  94 {
  95     if (!(myargs = ReadArgs(ARG_TEMPLATE, args, 0)))
  96     {
  97         Fault(IoErr(), 0, s, 255);
  98         cleanup(s, RETURN_FAIL);
  99     }
 100 }
 101
 102 /****************************************************************************************/
 103
 104 static void openpar(void)
 105 {
 106     ParMP = CreateMsgPort();
 107     if (!ParMP) cleanup("Failed to create msgport", RETURN_ERROR);
 108
 109     ParIO = (struct IOStdReq *)CreateIORequest(ParMP, sizeof(struct IOExtPar));
 110     if (!ParIO) cleanup("Failed to create IO request", RETURN_ERROR);
 111
 112     if (OpenDevice("parallel.device", 0, (struct IORequest *)ParIO, 0))
 113     {
 114         cleanup("Failed to open parallel.device", RETURN_ERROR);
 115     }
 116
 117     ParOpen = TRUE;
 118 }
 119
 120 /****************************************************************************************/
 121
 122 static void openfile(void)
 123 {
 124     fh = Open((STRPTR)args[ARG_FILE], MODE_OLDFILE);
 125     if (!fh)
 126     {
 127         Fault(IoErr(), 0, s, 255);
 128         cleanup(s, RETURN_FAIL);
 129     }
 130 }
 131
 132 /****************************************************************************************/
 133
 134 static BOOL WritePAR(APTR buf, ULONG size)
 135 {
 136     ParIO->io_Command = CMD_WRITE;
 137     ParIO->io_Data    = buf;
 138     ParIO->io_Length  = size;
 139
 140     return (DoIO((struct IORequest *)ParIO) == 0) ? TRUE : FALSE;
 141 }
 142
 143 /****************************************************************************************/
 144
 145 static void docopy(void)
 146 {
 147     LONG size;
 148
 149     do
 150     {
 151         size = Read(fh, buf, BUFSIZE);
 152         if (size == -1)
 153         {
 154             Fault(IoErr(), 0, s, 255);
 155             cleanup(s, RETURN_FAIL);
 156         }
 157
 158         if (!WritePAR(buf, size))
 159         {
 160             cleanup("Error writing to parallel.device", RETURN_FAIL);
 161         }
 162
 163     } while (size == BUFSIZE);
 164
 165 }
 166
 167 /****************************************************************************************/
 168
 169 int main(void)
 170 {
 171     getarguments();
 172     openpar();
 173     openfile();
 174     docopy();
 175     cleanup(NULL, 0);
 176
 177     return 0;
 178 }