usr/src/cmd/bnu/gio.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 #include "uucp.h"
  34
  35 #include "pk.h"
  36
  37 struct pack *Pk;
  38 extern int pkread(), pkwrite();
  39 extern void pkclose();
  40
  41 static int grdblk(char *, int);
  42 static int gwrblk(char *, int);
  43
  44 extern int packsize, xpacksize;
  45
  46 jmp_buf Getjbuf, Gfailbuf;
  47
  48 static void (*gsig)();
  49
  50 /* ARGSUSED */
  51 static void
  52 galarm(sig)
  53 int sig;
  54 {
  55         signal(SIGALRM, galarm);
  56         longjmp(Getjbuf, 1);
  57 }
  58
  59 void
  60 pkfail()
  61 {
  62         longjmp(Gfailbuf, 1);
  63 }
  64
  65 int
  66 gturnon()
  67 {
  68         struct pack *pkopen();
  69         if (setjmp(Gfailbuf))
  70                 return(FAIL);
  71         gsig=signal(SIGALRM, galarm);
  72         if (Debug > 4)
  73                 pkdebug = 1;
  74         Pk = pkopen(Ifn, Ofn);
  75         if ((int) Pk == NULL)
  76                 return(FAIL);
  77         return(0);
  78 }
  79
  80 int
  81 gturnoff()
  82 {
  83         if(setjmp(Gfailbuf))
  84                 return(FAIL);
  85         pkclose();
  86         (void) signal(SIGALRM, gsig);
  87         return(0);
  88 }
  89
  90 /*ARGSUSED*/
  91 int
  92 gwrmsg(type, str, fn)
  93 char type, *str;
  94 {
  95         char bufr[BUFSIZ], *s;
  96         int len, i;
  97
  98         if(setjmp(Gfailbuf))
  99                 return(FAIL);
 100         bufr[0] = type;
 101         s = &bufr[1];
 102         while (*str)
 103                 *s++ = *str++;
 104         *s = '\0';
 105         if (*(--s) == '\n')
 106                 *s = '\0';
 107         len = strlen(bufr) + 1;
 108         if ((i = len % xpacksize) != 0) {
 109                 len = len + xpacksize - i;
 110                 bufr[len - 1] = '\0';
 111         }
 112         gwrblk(bufr, len);
 113         return(0);
 114 }
 115
 116
 117 /*ARGSUSED*/
 118 int
 119 grdmsg(str, fn)
 120 char *str;
 121 {
 122         unsigned len;
 123
 124         if(setjmp(Gfailbuf))
 125                 return(FAIL);
 126         for (;;) {
 127                 len = pkread(str, packsize);
 128                 if (len == 0)
 129                         continue;
 130                 str += len;
 131                 if (*(str - 1) == '\0')
 132                         break;
 133         }
 134         return(0);
 135 }
 136
 137
 138 /*ARGSUSED*/
 139 int
 140 gwrdata(fp1, fn)
 141 FILE *fp1;
 142 {
 143         char bufr[BUFSIZ];
 144         int fd1;
 145         int len;
 146         int ret;
 147         unsigned long bytes;
 148
 149         if(setjmp(Gfailbuf))
 150                 return(FAIL);
 151         bytes = 0L;
 152         fd1 = fileno( fp1 );
 153         while ((len = read( fd1, bufr, BUFSIZ )) > 0) {
 154                 bytes += len;
 155                 putfilesize(bytes);
 156                 ret = gwrblk(bufr, len);
 157                 if (ret != len) {
 158                         return(FAIL);
 159                 }
 160                 if (len != BUFSIZ)
 161                         break;
 162         }
 163         ret = gwrblk(bufr, 0);
 164         return(0);
 165 }
 166
 167 /*ARGSUSED*/
 168 int
 169 grddata(fn, fp2)
 170 FILE *fp2;
 171 {
 172         int ret = SUCCESS;
 173         int fd2;
 174         int len;
 175         char bufr[BUFSIZ];
 176         unsigned long bytes;
 177
 178         if(setjmp(Gfailbuf))
 179                 return(FAIL);
 180         bytes = 0L;
 181         fd2 = fileno( fp2 );
 182         for (;;) {
 183                 len = grdblk(bufr, BUFSIZ);
 184                 if (len < 0) {
 185                         return(FAIL);
 186                 }
 187                 bytes += len;
 188                 putfilesize(bytes);
 189                 if ( ret == SUCCESS && write( fd2, bufr, len ) != len) {
 190                         ret = errno;
 191                         DEBUG(7, "grddata: write to file failed, errno %d\n", errno);
 192                 }
 193                 if (len < BUFSIZ)
 194                         break;
 195         }
 196         return(ret);
 197 }
 198
 199
 200 static
 201 int
 202 grdblk(blk, len)
 203 char *blk;
 204 {
 205         int i, ret;
 206
 207         for (i = 0; i < len; i += ret) {
 208                 ret = pkread(blk, len - i);
 209                 if (ret < 0)
 210                         return(FAIL);
 211                 blk += ret;
 212                 if (ret == 0)
 213                         return(i);
 214         }
 215         return(i);
 216 }
 217
 218
 219 static int
 220 gwrblk(blk, len)
 221 char *blk;
 222 {
 223         return(pkwrite(blk, len));
 224 }