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 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
23 /* All Rights Reserved */
24
25 /*
26 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
27 * Use is subject to license terms.
28 */
29
30 #include "uucp.h"
31
32 #ifdef D_PROTOCOL
33 #include <dk.h>
34
35 #define XBUFSIZ 1024
36 time_t time();
37 static jmp_buf Dfailbuf;
38 extern int drdblk();
39
40 /*
41 * Datakit protocol
42 */
43 /* ARGSUSED */
44 static void
dalarm(sig)45 dalarm(sig)
46 int sig;
47 {
48 longjmp(Dfailbuf,1);
49 }
50
51 static void (*dsig)();
52 #ifndef V8
53 static short dkrmode[3] = { DKR_BLOCK, 0, 0 };
54 static short dkeof[3] = { 106, 0, 0 }; /* End of File signal */
55 #endif
56
57 /*
58 * turn on protocol
59 */
60 int
dturnon()61 dturnon()
62 {
63 #ifdef V8
64 extern int dkp_ld;
65 #endif
66
67 dsig=signal(SIGALRM, dalarm);
68 #ifdef V8
69 if (dkproto(Ofn, dkp_ld) < 0)
70 {
71 DEBUG(3, "%s\n", "No dkp_ld");
72 return(-1);
73 }
74 #else
75 if((*Ioctl)(Ofn, DIOCRMODE, dkrmode) < 0) {
76 int ret;
77 ret=(*Ioctl)(Ofn, DIOCRMODE, dkrmode);
78 DEBUG(4, "dturnon: ret=%d, ", ret);
79 DEBUG(4, "Ofn=%d, ", Ofn);
80 DEBUG(4, "errno=%d\n", errno);
81 return(-1);
82 }
83 #endif /* V8 */
84 return(0);
85 }
86
87 int
dturnoff()88 dturnoff()
89 {
90 (void) signal(SIGALRM, dsig);
91 return(0);
92 }
93
94 /*
95 * write message across Datakit link
96 * type -> message type
97 * str -> message body (ascii string)
98 * fn -> Datakit file descriptor
99 * return
100 * SUCCESS -> message sent
101 * FAIL -> write failed
102 */
103 int
dwrmsg(type,str,fn)104 dwrmsg(type, str, fn)
105 register char *str;
106 int fn;
107 char type;
108 {
109 register char *s;
110 char bufr[XBUFSIZ];
111
112 bufr[0] = type;
113 s = &bufr[1];
114 while (*str)
115 *s++ = *str++;
116 *s = '\0';
117 if (*(--s) == '\n')
118 *s = '\0';
119 return((*Write)(fn, bufr, (unsigned) strlen(bufr) + 1) < 0 ? FAIL : SUCCESS);
120 }
121
122 /*
123 * read message from Datakit link
124 * str -> message buffer
125 * fn -> Datakit file descriptor
126 * return
127 * FAIL -> send timed out
128 * SUCCESS -> ok message in str
129 */
130 int
drdmsg(str,fn)131 drdmsg(str, fn)
132 register char *str;
133 {
134
135 register int len;
136
137 if(setjmp(Dfailbuf))
138 return(FAIL);
139
140 (void) alarm(60);
141 for (;;) {
142 if( (len = (*Read)(fn, str, XBUFSIZ)) <= 0) {
143 (void) alarm(0);
144 return(FAIL);
145 }
146 str += len;
147 if (*(str - 1) == '\0')
148 break;
149 }
150 (void) alarm(0);
151 return(SUCCESS);
152 }
153
154 /*
155 * read data from file fp1 and write
156 * on Datakit link
157 * fp1 -> file descriptor
158 * fn -> Datakit descriptor
159 * returns:
160 * FAIL ->failure in Datakit link
161 * SUCCESS -> ok
162 */
163 int
dwrdata(fp1,fn)164 dwrdata(fp1, fn)
165 FILE *fp1;
166 {
167 register int fd1;
168 register int len, ret;
169 unsigned long bytes;
170 char bufr[XBUFSIZ];
171
172 bytes = 0L;
173 fd1 = fileno( fp1 );
174 while ((len = read( fd1, bufr, XBUFSIZ )) > 0) {
175 bytes += len;
176 putfilesize(bytes);
177 ret = (*Write)(fn, bufr, (unsigned) len);
178 if (ret != len) {
179 return(FAIL);
180 }
181 if (len != XBUFSIZ)
182 break;
183 }
184 ASSERT(len >= 0, "DISK READ ERROR", strerror(errno), len);
185 #ifndef V8
186 (*Ioctl)(fn, DIOCXCTL, dkeof);
187 #endif
188 ret = (*Write)(fn, bufr, (unsigned) 0);
189 return(SUCCESS);
190 }
191
192 /*
193 * read data from Datakit link and
194 * write into file
195 * fp2 -> file descriptor
196 * fn -> Datakit descriptor
197 * returns:
198 * SUCCESS -> ok
199 * FAIL -> failure on Datakit link
200 */
201 int
drddata(fn,fp2)202 drddata(fn, fp2)
203 FILE *fp2;
204 {
205 register int fd2;
206 register int len;
207 register int ret = SUCCESS;
208 unsigned long bytes;
209 char bufr[XBUFSIZ];
210
211 bytes = 0L;
212 fd2 = fileno( fp2 );
213 for (;;) {
214 len = drdblk(bufr, XBUFSIZ, fn);
215 if (len < 0) {
216 return(FAIL);
217 }
218 bytes += len;
219 putfilesize(bytes);
220 if( ret == SUCCESS && write( fd2, bufr, len ) != len )
221 ret = errno;
222 if (len < XBUFSIZ)
223 break;
224 }
225 return(ret);
226 }
227
228 /*
229 * read block from Datakit link
230 * reads are timed
231 * blk -> address of buffer
232 * len -> size to read
233 * fn -> Datakit descriptor
234 * returns:
235 * FAIL -> link error timeout on link
236 * i -> # of bytes read
237 */
238 int
drdblk(blk,len,fn)239 drdblk(blk, len, fn)
240 register char *blk;
241 {
242 register int i, ret;
243 struct dkqqabo why;
244
245 if(setjmp(Dfailbuf))
246 return(FAIL);
247
248 for (i = 0; i < len; i += ret) {
249 (void) alarm(60);
250 if ((ret = (*Read)(fn, blk, (unsigned) len - i)) < 0) {
251 (void) alarm(0);
252 return(FAIL);
253 }
254 blk += ret;
255 if (ret == 0) { /* zero length block contains only EOF signal */
256 ioctl(fn, DIOCQQABO, &why);
257 if (why.rcv_ctlchar != dkeof[0])
258 i = FAIL;
259 break;
260 }
261 }
262 (void) alarm(0);
263 return(i);
264 }
265 #endif /* D_PROTOCOL */
266