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 } 225